diff --git a/examples/darwin-framework-tool/templates/tests/ciTests.json b/examples/darwin-framework-tool/templates/tests/ciTests.json index ba80c6aa2d8a60..d96481371393f7 100644 --- a/examples/darwin-framework-tool/templates/tests/ciTests.json +++ b/examples/darwin-framework-tool/templates/tests/ciTests.json @@ -31,6 +31,7 @@ "Test_TC_ACL_2_8", "Test_TC_ACL_2_9", "Test_TC_ACL_2_10", - "DL_LockUnlock" + "DL_LockUnlock", + "Test_TC_TIMESYNC_1_1" ] } diff --git a/scripts/tests/chiptest/__init__.py b/scripts/tests/chiptest/__init__.py index 1b72c818fe1ccf..c35c5392b12634 100644 --- a/scripts/tests/chiptest/__init__.py +++ b/scripts/tests/chiptest/__init__.py @@ -137,7 +137,8 @@ def _GetInDevelopmentTests() -> Set[str]: "Test_AddNewFabricFromExistingFabric.yaml", # chip-repl does not support GetCommissionerRootCertificate and IssueNocChain command "TestEqualities.yaml", # chip-repl does not support pseudo-cluster commands that return a value "TestExampleCluster.yaml", # chip-repl does not load custom pseudo clusters - "TestClientMonitoringCluster.yaml" # Client Monitoring Tests need a rework after the XML update + "TestClientMonitoringCluster.yaml", # Client Monitoring Tests need a rework after the XML update + "Test_TC_TIMESYNC_1_1.yaml" # Time sync SDK is not yet ready } @@ -187,14 +188,19 @@ def tests_with_command(chip_tool: str, is_manual: bool): if is_manual: test_tags.add(TestTag.MANUAL) + in_development_tests = [s.replace(".yaml", "") for s in _GetInDevelopmentTests()] + for name in result.stdout.decode("utf8").split("\n"): if not name: continue target = target_for_name(name) + tags = test_tags.copy() + if name in in_development_tests: + tags.add(TestTag.IN_DEVELOPMENT) yield TestDefinition( - run_name=name, name=name, target=target, tags=test_tags + run_name=name, name=name, target=target, tags=tags ) diff --git a/src/app/tests/suites/certification/Test_TC_TIMESYNC_1_1.yaml b/src/app/tests/suites/certification/Test_TC_TIMESYNC_1_1.yaml new file mode 100644 index 00000000000000..7bdfdbc9b2d86b --- /dev/null +++ b/src/app/tests/suites/certification/Test_TC_TIMESYNC_1_1.yaml @@ -0,0 +1,377 @@ +# 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. + +name: 133.1.1. [TC-TIMESYNC-1.1] Global attributes with server as DUT + +PICS: + - TIMESYNC.S + +config: + nodeId: 0x12344321 + cluster: "Time Synchronization" + endpoint: 0 + +tests: + - label: "Wait for the commissioned device to be retrieved" + cluster: "DelayCommands" + command: "WaitForCommissionee" + arguments: + values: + - name: "nodeId" + value: nodeId + + ########################## + # TS 2: Cluster revision + ########################## + - label: "TS2: read the global attribute: ClusterRevision" + command: "readAttribute" + attribute: "ClusterRevision" + response: + value: 2 + + ########################## + # TS 3: Feature map + ########################## + # TZ + - label: + "TS3: Given TIMESYNC.S.F00(TZ) ensure featuremap has the correct bit + set" + PICS: TIMESYNC.S.F00 + command: "readAttribute" + attribute: "FeatureMap" + response: + constraints: + type: bitmap32 + hasMasksSet: [0x1] + + - label: + "TS3: Given !TIMESYNC.S.F00(TZ) ensure featuremap has the correct bit + clear" + PICS: "!TIMESYNC.S.F00" + command: "readAttribute" + attribute: "FeatureMap" + response: + constraints: + type: bitmap32 + hasMasksClear: [0x1] + # NTPC + - label: + "TS3: Given TIMESYNC.S.F01(NTPC) ensure featuremap has the correct bit + set" + PICS: TIMESYNC.S.F01 + command: "readAttribute" + attribute: "FeatureMap" + response: + constraints: + type: bitmap32 + hasMasksSet: [0x2] + + - label: + "TS3: Given !TIMESYNC.S.F01(NTPC) ensure featuremap has the correct + bit clear" + PICS: "!TIMESYNC.S.F01" + command: "readAttribute" + attribute: "FeatureMap" + response: + constraints: + type: bitmap32 + hasMasksClear: [0x2] + + # NTPS + - label: + "TS3: Given TIMESYNC.S.F02(NTPS) ensure featuremap has the correct bit + set" + PICS: TIMESYNC.S.F02 + command: "readAttribute" + attribute: "FeatureMap" + response: + constraints: + type: bitmap32 + hasMasksSet: [0x4] + + - label: + "TS3: Given !TIMESYNC.S.F02(NTPS) ensure featuremap has the correct + bit clear" + PICS: "!TIMESYNC.S.F02" + command: "readAttribute" + attribute: "FeatureMap" + response: + constraints: + type: bitmap32 + hasMasksClear: [0x4] + + # TSC + - label: + "TS3: Given TIMESYNC.S.F03(TSC) ensure featuremap has the correct bit + set" + PICS: TIMESYNC.S.F03 + command: "readAttribute" + attribute: "FeatureMap" + response: + constraints: + type: bitmap32 + hasMasksSet: [0x8] + + - label: + "TS3: Given !TIMESYNC.S.F03(TSC) ensure featuremap has the correct bit + clear" + PICS: "!TIMESYNC.S.F03" + command: "readAttribute" + attribute: "FeatureMap" + response: + constraints: + type: bitmap32 + hasMasksClear: [0x8] + + ########################## + # TS 3: Feature map + ########################## + # Mandatory entries + - label: "TS4: Check for mandatory attributes in AttributeList" + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + contains: + [ + 0x0000, + 0x0001, + 0xFFF8, + 0xFFF9, + 0xFFFA, + 0xFFFB, + 0xFFFC, + 0xFFFD, + ] + + # Optional + - label: "TS4: Check for optional attribute TimeSource in AttributeList" + PICS: TIMESYNC.S.A0002 + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + contains: [0x0002] + + - label: "TS4: Check for optional attribute TimeSource not in AttributeList" + PICS: "!TIMESYNC.S.A0002" + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + excludes: [0x0002] + + # Feature TZ + - label: "TS4: Check for TZ feature-based attributes in AttributeList" + PICS: TIMESYNC.S.F00 + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + contains: [0x0005, 0x0006, 0x0007, 0x0008, 0x000A, 0x000B] + + - label: "TS4: Check for TZ feature-based attributes not in AttributeList" + PICS: "!TIMESYNC.S.F00" + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + excludes: [0x0005, 0x0006, 0x0007, 0x0008, 0x000A, 0x000B] + + # Feature NTPC + - label: "TS4: Check for NTPC feature-based attributes in AttributeList" + PICS: TIMESYNC.S.F01 + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + contains: [0x0004, 0x000C] + + - label: "TS4: Check for NTPC feature-based attributes not in AttributeList" + PICS: "!TIMESYNC.S.F01" + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + excludes: [0x0004, 0x000C] + + # Feature NTPS + - label: "TS4: Check for NTPS feature-based attributes in AttributeList" + PICS: TIMESYNC.S.F02 + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + contains: [0x0009] + + - label: "TS4: Check for NTPS feature-based attributes not in AttributeList" + PICS: "!TIMESYNC.S.F02" + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + excludes: [0x0009] + + # Feature TSC + - label: "TS4: Check for TSC feature-based attributes in AttributeList" + PICS: TIMESYNC.S.F03 + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + contains: [0x0003] + + - label: "TS4: Check for TSC feature-based attributes not in AttributeList" + PICS: "!TIMESYNC.S.F03" + command: "readAttribute" + attribute: "AttributeList" + response: + constraints: + excludes: [0x0003] + + # Note - additional exclusions not handled here + + ########################## + # TS 5: Event list - NOTE: disabled + ########################## + # mandatory + - label: "TS5: Check for mandatory events in EventList" + command: "readAttribute" + attribute: "EventList" + response: + constraints: + contains: [0x03] + + # Feature TZ + - label: "TS5: Check for TZ feature-based events in EventList" + PICS: TIMESYNC.S.F00 + command: "readAttribute" + attribute: "EventList" + response: + constraints: + contains: [0x00, 0x01, 0x02] + + - label: "TS5: Check for TZ feature-based events not in EventList" + PICS: "!TIMESYNC.S.F00" + command: "readAttribute" + attribute: "EventList" + response: + constraints: + excludes: [0x00, 0x01, 0x02] + + # Feature TSC + - label: "TS5: Check for TSC feature-based events in EventList" + PICS: TIMESYNC.S.F03 + command: "readAttribute" + attribute: "EventList" + response: + constraints: + contains: [0x04] + - label: "TS5: Check for TSC feature-based events not in EventList" + PICS: "!TIMESYNC.S.F03" + command: "readAttribute" + attribute: "EventList" + response: + constraints: + excludes: [0x04] + + # Note - additional exclusions not handled here + + ########################## + # TS 6: AcceptedCommandList + ########################## + # mandatory + - label: "TS6: Check for mandatory commands in AcceptedCommandList" + command: "readAttribute" + attribute: "AcceptedCommandList" + response: + constraints: + contains: [0x00] + + # Feature TZ + - label: "TS6: Check for TZ feature-based commands in AcceptedCommandList" + PICS: TIMESYNC.S.F00 + command: "readAttribute" + attribute: "AcceptedCommandList" + response: + constraints: + contains: [0x02, 0x04] + + - label: + "TS6: Check for TZ feature-based commands in not AcceptedCommandList" + PICS: "!TIMESYNC.S.F00" + command: "readAttribute" + attribute: "AcceptedCommandList" + response: + constraints: + excludes: [0x02, 0x04] + + # Feature NTPC + - label: "TS6: Check for NTPC feature-based commands in AcceptedCommandList" + PICS: TIMESYNC.S.F01 + command: "readAttribute" + attribute: "AcceptedCommandList" + response: + constraints: + contains: [0x05] + + - label: + "TS6: Check for NTPC feature-based commands in not AcceptedCommandList" + PICS: "!TIMESYNC.S.F01" + command: "readAttribute" + attribute: "AcceptedCommandList" + response: + constraints: + excludes: [0x05] + + # Feature TSC + - label: "TS6: Check for TSC feature-based commands in AcceptedCommandList" + PICS: TIMESYNC.S.F03 + command: "readAttribute" + attribute: "AcceptedCommandList" + response: + constraints: + contains: [0x01] + + - label: + "TS6: Check for TSC feature-based commands in not AcceptedCommandList" + PICS: "!TIMESYNC.S.F03" + command: "readAttribute" + attribute: "AcceptedCommandList" + response: + constraints: + excludes: [0x01] + + # NOTE: exclusions not checked + + ########################## + # TS 7: GeneratedCommandList + ########################## + # Feature TZ + - label: "TS6: Check for TZ feature-based commands in AcceptedCommandList" + PICS: TIMESYNC.S.F00 + command: "readAttribute" + attribute: "GeneratedCommandList" + response: + constraints: + contains: [0x03] + + - label: + "TS6: Check for TZ feature-based commands in not AcceptedCommandList" + PICS: "!TIMESYNC.S.F00" + command: "readAttribute" + attribute: "GeneratedCommandList" + response: + constraints: + excludes: [0x03] diff --git a/src/app/tests/suites/ciTests.json b/src/app/tests/suites/ciTests.json index 63380e81651c69..751631d0ae3760 100644 --- a/src/app/tests/suites/ciTests.json +++ b/src/app/tests/suites/ciTests.json @@ -178,6 +178,7 @@ "Test_TC_DGTHREAD_2_3", "Test_TC_DGTHREAD_2_4" ], + "TimeSynchronization": ["Test_TC_TIMESYNC_1_1"], "WiFiNetworkDiagnostics": [ "Test_TC_DGWIFI_1_1", "Test_TC_DGWIFI_2_1", @@ -312,6 +313,7 @@ "Thermostat", "ThermostatUserConfiguration", "ThreadNetworkDiagnostics", + "TimeSynchronization", "UserLabel", "WiFiNetworkDiagnostics", "WindowCovering", diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 4726c9905368ad..50175ae37b32cb 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -7982,6 +7982,435 @@ } ] }, + { + "name": "Time Synchronization", + "code": 56, + "mfgCode": null, + "define": "TIME_SYNCHRONIZATION_CLUSTER", + "side": "client", + "enabled": 1, + "commands": [ + { + "name": "SetUtcTime", + "code": 0, + "mfgCode": null, + "source": "client", + "incoming": 1, + "outgoing": 1 + }, + { + "name": "SetTrustedTimeSource", + "code": 1, + "mfgCode": null, + "source": "client", + "incoming": 1, + "outgoing": 1 + }, + { + "name": "SetTimeZone", + "code": 2, + "mfgCode": null, + "source": "client", + "incoming": 1, + "outgoing": 1 + }, + { + "name": "SetDSTOffset", + "code": 4, + "mfgCode": null, + "source": "client", + "incoming": 1, + "outgoing": 1 + }, + { + "name": "SetDefaultNTP", + "code": 5, + "mfgCode": null, + "source": "client", + "incoming": 1, + "outgoing": 1 + } + ], + "attributes": [ + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "client", + "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": "client", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Time Synchronization", + "code": 56, + "mfgCode": null, + "define": "TIME_SYNCHRONIZATION_CLUSTER", + "side": "server", + "enabled": 0, + "commands": [ + { + "name": "SetTimeZoneResponse", + "code": 3, + "mfgCode": null, + "source": "server", + "incoming": 1, + "outgoing": 1 + } + ], + "attributes": [ + { + "name": "UTCTime", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "epoch_us", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "Granularity", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "GranularityEnum", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x00", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "TimeSource", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "TimeSourceEnum", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x00", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "TrustedTimeSource", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "TrustedTimeSourceStruct", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "DefaultNTP", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "TimeZone", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "DSTOffset", + "code": 6, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "LocalTime", + "code": 7, + "mfgCode": null, + "side": "server", + "type": "epoch_us", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x00", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "TimeZoneDatabase", + "code": 8, + "mfgCode": null, + "side": "server", + "type": "TimeZoneDatabaseEnum", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "NTPServerAvailable", + "code": 9, + "mfgCode": null, + "side": "server", + "type": "boolean", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "TimeZoneListMaxSize", + "code": 10, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "3", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "DSTOffsetListMaxSize", + "code": 11, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "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": "", + "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": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "EventList", + "code": 65530, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "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": "", + "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": "DSTTableEmpty", + "code": 0, + "mfgCode": null, + "side": "server", + "included": 1 + }, + { + "name": "DSTStatus", + "code": 1, + "mfgCode": null, + "side": "server", + "included": 1 + }, + { + "name": "TimeZoneStatus", + "code": 2, + "mfgCode": null, + "side": "server", + "included": 1 + }, + { + "name": "TimeFailure", + "code": 3, + "mfgCode": null, + "side": "server", + "included": 1 + }, + { + "name": "MissingTrustedTimeSource", + "code": 4, + "mfgCode": null, + "side": "server", + "included": 1 + } + ] + }, { "name": "Bridged Device Basic Information", "code": 57, @@ -24846,4 +25275,4 @@ "deviceIdentifier": 22 } ] -} \ No newline at end of file +} diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 1337fd000a1edc..e017be0e660278 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -10322,6 +10322,115 @@ public TimeSynchronizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); + public void setUTCTime( + DefaultClusterCallback callback, + Long UTCTime, + Integer granularity, + Optional timeSource) { + setUTCTime(chipClusterPtr, callback, UTCTime, granularity, timeSource, null); + } + + public void setUTCTime( + DefaultClusterCallback callback, + Long UTCTime, + Integer granularity, + Optional timeSource, + int timedInvokeTimeoutMs) { + setUTCTime(chipClusterPtr, callback, UTCTime, granularity, timeSource, timedInvokeTimeoutMs); + } + + public void setTrustedTimeSource( + DefaultClusterCallback callback, + @Nullable + ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct + trustedTimeSource) { + setTrustedTimeSource(chipClusterPtr, callback, trustedTimeSource, null); + } + + public void setTrustedTimeSource( + DefaultClusterCallback callback, + @Nullable + ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct + trustedTimeSource, + int timedInvokeTimeoutMs) { + setTrustedTimeSource(chipClusterPtr, callback, trustedTimeSource, timedInvokeTimeoutMs); + } + + public void setTimeZone( + SetTimeZoneResponseCallback callback, + ArrayList timeZone) { + setTimeZone(chipClusterPtr, callback, timeZone, null); + } + + public void setTimeZone( + SetTimeZoneResponseCallback callback, + ArrayList timeZone, + int timedInvokeTimeoutMs) { + setTimeZone(chipClusterPtr, callback, timeZone, timedInvokeTimeoutMs); + } + + public void setDSTOffset( + DefaultClusterCallback callback, + ArrayList DSTOffset) { + setDSTOffset(chipClusterPtr, callback, DSTOffset, null); + } + + public void setDSTOffset( + DefaultClusterCallback callback, + ArrayList DSTOffset, + int timedInvokeTimeoutMs) { + setDSTOffset(chipClusterPtr, callback, DSTOffset, timedInvokeTimeoutMs); + } + + public void setDefaultNTP(DefaultClusterCallback callback, @Nullable String defaultNTP) { + setDefaultNTP(chipClusterPtr, callback, defaultNTP, null); + } + + public void setDefaultNTP( + DefaultClusterCallback callback, @Nullable String defaultNTP, int timedInvokeTimeoutMs) { + setDefaultNTP(chipClusterPtr, callback, defaultNTP, timedInvokeTimeoutMs); + } + + private native void setUTCTime( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long UTCTime, + Integer granularity, + Optional timeSource, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setTrustedTimeSource( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable + ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct + trustedTimeSource, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setTimeZone( + long chipClusterPtr, + SetTimeZoneResponseCallback Callback, + ArrayList timeZone, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setDSTOffset( + long chipClusterPtr, + DefaultClusterCallback Callback, + ArrayList DSTOffset, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setDefaultNTP( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable String defaultNTP, + @Nullable Integer timedInvokeTimeoutMs); + + public interface SetTimeZoneResponseCallback { + void onSuccess(Boolean DSTOffsetRequired); + + void onError(Exception error); + } + public interface UTCTimeAttributeCallback { void onSuccess(@Nullable Long value); diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 474738799cb898..7cb79cdf6905da 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -5353,6 +5353,31 @@ public void onError(Exception ex) { } } + public static class DelegatedTimeSynchronizationClusterSetTimeZoneResponseCallback + implements ChipClusters.TimeSynchronizationCluster.SetTimeZoneResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean DSTOffsetRequired) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo DSTOffsetRequiredResponseValue = + new CommandResponseInfo("DSTOffsetRequired", "Boolean"); + responseValues.put(DSTOffsetRequiredResponseValue, DSTOffsetRequired); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + public static class DelegatedTimeSynchronizationClusterUTCTimeAttributeCallback implements ChipClusters.TimeSynchronizationCluster.UTCTimeAttributeCallback, DelegatedClusterCallback { @@ -17740,6 +17765,102 @@ public Map> getCommandMap() { "ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); Map timeSynchronizationClusterInteractionInfoMap = new LinkedHashMap<>(); + Map timeSynchronizationsetUTCTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo timeSynchronizationsetUTCTimeUTCTimeCommandParameterInfo = + new CommandParameterInfo("UTCTime", Long.class, Long.class); + timeSynchronizationsetUTCTimeCommandParams.put( + "UTCTime", timeSynchronizationsetUTCTimeUTCTimeCommandParameterInfo); + + CommandParameterInfo timeSynchronizationsetUTCTimegranularityCommandParameterInfo = + new CommandParameterInfo("granularity", Integer.class, Integer.class); + timeSynchronizationsetUTCTimeCommandParams.put( + "granularity", timeSynchronizationsetUTCTimegranularityCommandParameterInfo); + + CommandParameterInfo timeSynchronizationsetUTCTimetimeSourceCommandParameterInfo = + new CommandParameterInfo("timeSource", Optional.class, Integer.class); + timeSynchronizationsetUTCTimeCommandParams.put( + "timeSource", timeSynchronizationsetUTCTimetimeSourceCommandParameterInfo); + + InteractionInfo timeSynchronizationsetUTCTimeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .setUTCTime( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("UTCTime"), + (Integer) commandArguments.get("granularity"), + (Optional) commandArguments.get("timeSource")); + }, + () -> new DelegatedDefaultClusterCallback(), + timeSynchronizationsetUTCTimeCommandParams); + timeSynchronizationClusterInteractionInfoMap.put( + "setUTCTime", timeSynchronizationsetUTCTimeInteractionInfo); + Map timeSynchronizationsetTrustedTimeSourceCommandParams = + new LinkedHashMap(); + InteractionInfo timeSynchronizationsetTrustedTimeSourceInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .setTrustedTimeSource( + (DefaultClusterCallback) callback, + (ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct) + commandArguments.get("trustedTimeSource")); + }, + () -> new DelegatedDefaultClusterCallback(), + timeSynchronizationsetTrustedTimeSourceCommandParams); + timeSynchronizationClusterInteractionInfoMap.put( + "setTrustedTimeSource", timeSynchronizationsetTrustedTimeSourceInteractionInfo); + Map timeSynchronizationsetTimeZoneCommandParams = + new LinkedHashMap(); + InteractionInfo timeSynchronizationsetTimeZoneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .setTimeZone( + (ChipClusters.TimeSynchronizationCluster.SetTimeZoneResponseCallback) + callback, + (ArrayList) + commandArguments.get("timeZone")); + }, + () -> new DelegatedTimeSynchronizationClusterSetTimeZoneResponseCallback(), + timeSynchronizationsetTimeZoneCommandParams); + timeSynchronizationClusterInteractionInfoMap.put( + "setTimeZone", timeSynchronizationsetTimeZoneInteractionInfo); + Map timeSynchronizationsetDSTOffsetCommandParams = + new LinkedHashMap(); + InteractionInfo timeSynchronizationsetDSTOffsetInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .setDSTOffset( + (DefaultClusterCallback) callback, + (ArrayList) + commandArguments.get("DSTOffset")); + }, + () -> new DelegatedDefaultClusterCallback(), + timeSynchronizationsetDSTOffsetCommandParams); + timeSynchronizationClusterInteractionInfoMap.put( + "setDSTOffset", timeSynchronizationsetDSTOffsetInteractionInfo); + Map timeSynchronizationsetDefaultNTPCommandParams = + new LinkedHashMap(); + CommandParameterInfo timeSynchronizationsetDefaultNTPdefaultNTPCommandParameterInfo = + new CommandParameterInfo("defaultNTP", String.class, String.class); + timeSynchronizationsetDefaultNTPCommandParams.put( + "defaultNTP", timeSynchronizationsetDefaultNTPdefaultNTPCommandParameterInfo); + + InteractionInfo timeSynchronizationsetDefaultNTPInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .setDefaultNTP( + (DefaultClusterCallback) callback, + (String) commandArguments.get("defaultNTP")); + }, + () -> new DelegatedDefaultClusterCallback(), + timeSynchronizationsetDefaultNTPCommandParams); + timeSynchronizationClusterInteractionInfoMap.put( + "setDefaultNTP", timeSynchronizationsetDefaultNTPInteractionInfo); commandMap.put("timeSynchronization", timeSynchronizationClusterInteractionInfoMap); Map bridgedDeviceBasicInformationClusterInteractionInfoMap = new LinkedHashMap<>(); diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 483c1f2ea30cea..e24ce02127e23b 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -187,6 +187,7 @@ class TestList : public Command printf("Test_TC_DGTHREAD_2_2\n"); printf("Test_TC_DGTHREAD_2_3\n"); printf("Test_TC_DGTHREAD_2_4\n"); + printf("Test_TC_TIMESYNC_1_1\n"); printf("Test_TC_ULABEL_1_1\n"); printf("Test_TC_ULABEL_2_1\n"); printf("Test_TC_ULABEL_2_2\n"); @@ -53602,6 +53603,579 @@ class Test_TC_DGTHREAD_2_4Suite : public TestCommand } }; +class Test_TC_TIMESYNC_1_1Suite : public TestCommand +{ +public: + Test_TC_TIMESYNC_1_1Suite(CredentialIssuerCommands * credsIssuerConfig) : + TestCommand("Test_TC_TIMESYNC_1_1", 35, credsIssuerConfig) + { + AddArgument("nodeId", 0, UINT64_MAX, &mNodeId); + AddArgument("cluster", &mCluster); + AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint); + AddArgument("timeout", 0, UINT16_MAX, &mTimeout); + } + + ~Test_TC_TIMESYNC_1_1Suite() {} + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mTimeout.ValueOr(kTimeoutInSeconds)); + } + +private: + chip::Optional mNodeId; + chip::Optional mCluster; + chip::Optional mEndpoint; + chip::Optional mTimeout; + + chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; } + + // + // Tests methods + // + + void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override + { + bool shouldContinue = false; + + switch (mTestIndex - 1) + { + case 0: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + shouldContinue = true; + break; + case 1: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + uint16_t value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckValue("clusterRevision", value, 2U)); + } + break; + case 2: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + uint32_t value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintType("value", "bitmap32", "bitmap32")); + VerifyOrReturn(CheckConstraintHasMasksSet("value", value, 1UL)); + } + break; + case 3: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + uint32_t value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintType("value", "bitmap32", "bitmap32")); + VerifyOrReturn(CheckConstraintHasMasksClear("value", value, 1UL)); + } + break; + case 4: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + uint32_t value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintType("value", "bitmap32", "bitmap32")); + VerifyOrReturn(CheckConstraintHasMasksSet("value", value, 2UL)); + } + break; + case 5: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + uint32_t value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintType("value", "bitmap32", "bitmap32")); + VerifyOrReturn(CheckConstraintHasMasksClear("value", value, 2UL)); + } + break; + case 6: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + uint32_t value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintType("value", "bitmap32", "bitmap32")); + VerifyOrReturn(CheckConstraintHasMasksSet("value", value, 4UL)); + } + break; + case 7: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + uint32_t value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintType("value", "bitmap32", "bitmap32")); + VerifyOrReturn(CheckConstraintHasMasksClear("value", value, 4UL)); + } + break; + case 8: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + uint32_t value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintType("value", "bitmap32", "bitmap32")); + VerifyOrReturn(CheckConstraintHasMasksSet("value", value, 8UL)); + } + break; + case 9: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + uint32_t value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintType("value", "bitmap32", "bitmap32")); + VerifyOrReturn(CheckConstraintHasMasksClear("value", value, 8UL)); + } + break; + case 10: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 0UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 1UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 65528UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 65529UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 65530UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 65531UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 65532UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 65533UL)); + } + break; + case 11: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 2UL)); + } + break; + case 12: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 2UL)); + } + break; + case 13: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 5UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 6UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 7UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 8UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 10UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 11UL)); + } + break; + case 14: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 5UL)); + VerifyOrReturn(CheckConstraintExcludes("value", value, 6UL)); + VerifyOrReturn(CheckConstraintExcludes("value", value, 7UL)); + VerifyOrReturn(CheckConstraintExcludes("value", value, 8UL)); + VerifyOrReturn(CheckConstraintExcludes("value", value, 10UL)); + VerifyOrReturn(CheckConstraintExcludes("value", value, 11UL)); + } + break; + case 15: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 4UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 12UL)); + } + break; + case 16: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 4UL)); + VerifyOrReturn(CheckConstraintExcludes("value", value, 12UL)); + } + break; + case 17: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 9UL)); + } + break; + case 18: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 9UL)); + } + break; + case 19: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 3UL)); + } + break; + case 20: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 3UL)); + } + break; + case 21: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 3UL)); + } + break; + case 22: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 0UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 1UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 2UL)); + } + break; + case 23: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 0UL)); + VerifyOrReturn(CheckConstraintExcludes("value", value, 1UL)); + VerifyOrReturn(CheckConstraintExcludes("value", value, 2UL)); + } + break; + case 24: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 4UL)); + } + break; + case 25: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 4UL)); + } + break; + case 26: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 0UL)); + } + break; + case 27: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 2UL)); + VerifyOrReturn(CheckConstraintContains("value", value, 4UL)); + } + break; + case 28: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 2UL)); + VerifyOrReturn(CheckConstraintExcludes("value", value, 4UL)); + } + break; + case 29: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 5UL)); + } + break; + case 30: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 5UL)); + } + break; + case 31: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 1UL)); + } + break; + case 32: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 1UL)); + } + break; + case 33: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintContains("value", value, 3UL)); + } + break; + case 34: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::DataModel::DecodableList value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckConstraintExcludes("value", value, 3UL)); + } + break; + default: + LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT)); + } + + if (shouldContinue) + { + ContinueOnChipMainThread(CHIP_NO_ERROR); + } + } + + CHIP_ERROR DoTestStep(uint16_t testIndex) override + { + using namespace chip::app::Clusters; + switch (testIndex) + { + case 0: { + LogStep(0, "Wait for the commissioned device to be retrieved"); + ListFreer listFreer; + chip::app::Clusters::DelayCommands::Commands::WaitForCommissionee::Type value; + value.nodeId = mNodeId.HasValue() ? mNodeId.Value() : 305414945ULL; + return WaitForCommissionee(kIdentityAlpha, value); + } + case 1: { + LogStep(1, "TS2: read the global attribute: ClusterRevision"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::ClusterRevision::Id, true, chip::NullOptional); + } + case 2: { + LogStep(2, "TS3: Given TIMESYNC.S.F00(TZ) ensure featuremap has the correct bit set"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::FeatureMap::Id, true, chip::NullOptional); + } + case 3: { + LogStep(3, "TS3: Given !TIMESYNC.S.F00(TZ) ensure featuremap has the correct bit clear"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::FeatureMap::Id, true, chip::NullOptional); + } + case 4: { + LogStep(4, "TS3: Given TIMESYNC.S.F01(NTPC) ensure featuremap has the correct bit set"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::FeatureMap::Id, true, chip::NullOptional); + } + case 5: { + LogStep(5, "TS3: Given !TIMESYNC.S.F01(NTPC) ensure featuremap has the correct bit clear"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::FeatureMap::Id, true, chip::NullOptional); + } + case 6: { + LogStep(6, "TS3: Given TIMESYNC.S.F02(NTPS) ensure featuremap has the correct bit set"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F02"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::FeatureMap::Id, true, chip::NullOptional); + } + case 7: { + LogStep(7, "TS3: Given !TIMESYNC.S.F02(NTPS) ensure featuremap has the correct bit clear"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F02"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::FeatureMap::Id, true, chip::NullOptional); + } + case 8: { + LogStep(8, "TS3: Given TIMESYNC.S.F03(TSC) ensure featuremap has the correct bit set"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::FeatureMap::Id, true, chip::NullOptional); + } + case 9: { + LogStep(9, "TS3: Given !TIMESYNC.S.F03(TSC) ensure featuremap has the correct bit clear"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::FeatureMap::Id, true, chip::NullOptional); + } + case 10: { + LogStep(10, "TS4: Check for mandatory attributes in AttributeList"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 11: { + LogStep(11, "TS4: Check for optional attribute TimeSource in AttributeList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 12: { + LogStep(12, "TS4: Check for optional attribute TimeSource not in AttributeList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 13: { + LogStep(13, "TS4: Check for TZ feature-based attributes in AttributeList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 14: { + LogStep(14, "TS4: Check for TZ feature-based attributes not in AttributeList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 15: { + LogStep(15, "TS4: Check for NTPC feature-based attributes in AttributeList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 16: { + LogStep(16, "TS4: Check for NTPC feature-based attributes not in AttributeList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 17: { + LogStep(17, "TS4: Check for NTPS feature-based attributes in AttributeList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F02"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 18: { + LogStep(18, "TS4: Check for NTPS feature-based attributes not in AttributeList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F02"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 19: { + LogStep(19, "TS4: Check for TSC feature-based attributes in AttributeList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 20: { + LogStep(20, "TS4: Check for TSC feature-based attributes not in AttributeList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AttributeList::Id, true, chip::NullOptional); + } + case 21: { + LogStep(21, "TS5: Check for mandatory events in EventList"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::EventList::Id, true, chip::NullOptional); + } + case 22: { + LogStep(22, "TS5: Check for TZ feature-based events in EventList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::EventList::Id, true, chip::NullOptional); + } + case 23: { + LogStep(23, "TS5: Check for TZ feature-based events not in EventList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::EventList::Id, true, chip::NullOptional); + } + case 24: { + LogStep(24, "TS5: Check for TSC feature-based events in EventList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::EventList::Id, true, chip::NullOptional); + } + case 25: { + LogStep(25, "TS5: Check for TSC feature-based events not in EventList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::EventList::Id, true, chip::NullOptional); + } + case 26: { + LogStep(26, "TS6: Check for mandatory commands in AcceptedCommandList"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AcceptedCommandList::Id, true, chip::NullOptional); + } + case 27: { + LogStep(27, "TS6: Check for TZ feature-based commands in AcceptedCommandList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AcceptedCommandList::Id, true, chip::NullOptional); + } + case 28: { + LogStep(28, "TS6: Check for TZ feature-based commands in not AcceptedCommandList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AcceptedCommandList::Id, true, chip::NullOptional); + } + case 29: { + LogStep(29, "TS6: Check for NTPC feature-based commands in AcceptedCommandList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AcceptedCommandList::Id, true, chip::NullOptional); + } + case 30: { + LogStep(30, "TS6: Check for NTPC feature-based commands in not AcceptedCommandList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AcceptedCommandList::Id, true, chip::NullOptional); + } + case 31: { + LogStep(31, "TS6: Check for TSC feature-based commands in AcceptedCommandList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AcceptedCommandList::Id, true, chip::NullOptional); + } + case 32: { + LogStep(32, "TS6: Check for TSC feature-based commands in not AcceptedCommandList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::AcceptedCommandList::Id, true, chip::NullOptional); + } + case 33: { + LogStep(33, "TS6: Check for TZ feature-based commands in AcceptedCommandList"); + VerifyOrDo(!ShouldSkip("TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::GeneratedCommandList::Id, true, chip::NullOptional); + } + case 34: { + LogStep(34, "TS6: Check for TZ feature-based commands in not AcceptedCommandList"); + VerifyOrDo(!ShouldSkip("!TIMESYNC.S.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR)); + return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TimeSynchronization::Id, + TimeSynchronization::Attributes::GeneratedCommandList::Id, true, chip::NullOptional); + } + } + return CHIP_NO_ERROR; + } +}; + class Test_TC_ULABEL_1_1Suite : public TestCommand { public: @@ -118942,6 +119516,7 @@ void registerCommandsTests(Commands & commands, CredentialIssuerCommands * creds make_unique(credsIssuerConfig), make_unique(credsIssuerConfig), make_unique(credsIssuerConfig), + make_unique(credsIssuerConfig), make_unique(credsIssuerConfig), make_unique(credsIssuerConfig), make_unique(credsIssuerConfig), diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h new file mode 100644 index 00000000000000..67573317f066ae --- /dev/null +++ b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h @@ -0,0 +1,832 @@ +/* + * + * 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 +#include +#include +#include +#include +#include +#include +#include + +// List specific responses +typedef void (*IdentifyGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IdentifyAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*IdentifyEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*IdentifyAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupsGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupsAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupsAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ScenesGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ScenesAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ScenesEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ScenesAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffSwitchConfigurationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffSwitchConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LevelControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LevelControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LevelControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*LevelControlAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BinaryInputBasicGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BinaryInputBasicAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BinaryInputBasicEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BinaryInputBasicAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorDeviceTypeListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorServerListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorClientListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorPartsListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingBindingListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AccessControlAclListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::AccessControl::Structs::AccessControlEntryStruct::DecodableType> & data); +typedef void (*AccessControlExtensionListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::AccessControl::Structs::AccessControlExtensionStruct::DecodableType> & data); +typedef void (*AccessControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccessControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccessControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AccessControlAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsActionListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsEndpointListsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BasicInformationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BasicInformationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BasicInformationEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BasicInformationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateProviderEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateProviderAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateRequestorDefaultOTAProvidersListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType> & data); +typedef void (*OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateRequestorEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateRequestorAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationSupportedLocalesListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitLocalizationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitLocalizationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitLocalizationEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitLocalizationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationSourcesListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceActiveWiredFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceActiveBatFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceActiveBatChargeFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralCommissioningGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralCommissioningAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralCommissioningEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralCommissioningAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*NetworkCommissioningNetworksListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*NetworkCommissioningGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*NetworkCommissioningAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*NetworkCommissioningEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*NetworkCommissioningAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DiagnosticLogsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DiagnosticLogsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DiagnosticLogsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DiagnosticLogsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsNetworkInterfacesListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsActiveRadioFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SoftwareDiagnosticsThreadMetricsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetricsStruct::DecodableType> & data); +typedef void (*SoftwareDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SoftwareDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SoftwareDiagnosticsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SoftwareDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsNeighborTableListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType> & data); +typedef void (*ThreadNetworkDiagnosticsRouteTableListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WiFiNetworkDiagnosticsEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WiFiNetworkDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*EthernetNetworkDiagnosticsEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*EthernetNetworkDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeSynchronizationTimeZoneListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*TimeSynchronizationDSTOffsetListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*TimeSynchronizationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeSynchronizationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeSynchronizationEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*TimeSynchronizationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BridgedDeviceBasicInformationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BridgedDeviceBasicInformationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BridgedDeviceBasicInformationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BridgedDeviceBasicInformationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SwitchGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SwitchAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SwitchEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SwitchAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AdministratorCommissioningGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AdministratorCommissioningAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AdministratorCommissioningEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AdministratorCommissioningAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsNOCsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*OperationalCredentialsFabricsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptorStruct::DecodableType> & data); +typedef void (*OperationalCredentialsTrustedRootCertificatesListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GroupKeyManagementGroupKeyMapListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*GroupKeyManagementGroupTableListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*GroupKeyManagementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GroupKeyManagementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GroupKeyManagementEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupKeyManagementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelLabelListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelLabelListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanStateGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanStateAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanStateEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanStateAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*IcdManagementRegisteredClientsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::IcdManagement::Structs::MonitoringRegistrationStruct::DecodableType> & data); +typedef void (*IcdManagementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IcdManagementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IcdManagementEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*IcdManagementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectSupportedModesListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*RefrigeratorAlarmGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RefrigeratorAlarmAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RefrigeratorAlarmEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*RefrigeratorAlarmAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AirQualityGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AirQualityAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AirQualityEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AirQualityAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SmokeCoAlarmGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SmokeCoAlarmAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SmokeCoAlarmEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SmokeCoAlarmAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*HepaFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*HepaFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*HepaFilterMonitoringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*HepaFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActivatedCarbonFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActivatedCarbonFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActivatedCarbonFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActivatedCarbonFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*CeramicFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*CeramicFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*CeramicFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*CeramicFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectrostaticFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectrostaticFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectrostaticFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectrostaticFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UvFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UvFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UvFilterMonitoringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UvFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IonizingFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IonizingFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IonizingFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IonizingFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ZeoliteFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ZeoliteFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ZeoliteFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ZeoliteFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OzoneFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OzoneFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OzoneFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OzoneFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WaterTankMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WaterTankMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WaterTankMonitoringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*WaterTankMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FuelTankMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FuelTankMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FuelTankMonitoringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FuelTankMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*InkCartridgeMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*InkCartridgeMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*InkCartridgeMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*InkCartridgeMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TonerCartridgeMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TonerCartridgeMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TonerCartridgeMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TonerCartridgeMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DoorLockGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DoorLockAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DoorLockEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DoorLockAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*WindowCoveringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WindowCoveringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WindowCoveringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*WindowCoveringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BarrierControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BarrierControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BarrierControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BarrierControlAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PumpConfigurationAndControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PumpConfigurationAndControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PumpConfigurationAndControlEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PumpConfigurationAndControlAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FanControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FanControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FanControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FanControlAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatUserInterfaceConfigurationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ColorControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ColorControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ColorControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ColorControlAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BallastConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BallastConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BallastConfigurationEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BallastConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IlluminanceMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IlluminanceMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IlluminanceMeasurementEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IlluminanceMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TemperatureMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TemperatureMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TemperatureMeasurementEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TemperatureMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PressureMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PressureMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PressureMeasurementEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*PressureMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FlowMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FlowMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FlowMeasurementEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FlowMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RelativeHumidityMeasurementEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RelativeHumidityMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OccupancySensingGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OccupancySensingAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OccupancySensingEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OccupancySensingAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WakeOnLanGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WakeOnLanAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WakeOnLanEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*WakeOnLanAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelChannelListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*TargetNavigatorTargetListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*TargetNavigatorGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TargetNavigatorAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TargetNavigatorEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*TargetNavigatorAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaPlaybackGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaPlaybackAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaPlaybackEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*MediaPlaybackAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputInputListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*LowPowerGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LowPowerAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*LowPowerEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*LowPowerAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*KeypadInputGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*KeypadInputAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*KeypadInputEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*KeypadInputAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherAcceptHeaderListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputOutputListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherCatalogListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicAllowedVendorListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccountLoginGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccountLoginAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccountLoginEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AccountLoginAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ElectricalMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectricalMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectricalMeasurementEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectricalMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingListInt8uListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingListOctetStringListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingListStructOctetStringListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*UnitTestingListNullablesAndOptionalsStructListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::DecodableType> & data); +typedef void (*UnitTestingListLongOctetStringListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingListFabricScopedListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h new file mode 100644 index 00000000000000..6052ea278f2038 --- /dev/null +++ b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h @@ -0,0 +1,794 @@ +/* + * + * 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 +#include + +#include +#include +#include + +namespace chip { +namespace Controller { + +class DLL_EXPORT IdentifyCluster : public ClusterBase +{ +public: + IdentifyCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~IdentifyCluster() {} +}; + +class DLL_EXPORT GroupsCluster : public ClusterBase +{ +public: + GroupsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~GroupsCluster() {} +}; + +class DLL_EXPORT ScenesCluster : public ClusterBase +{ +public: + ScenesCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ScenesCluster() {} +}; + +class DLL_EXPORT OnOffCluster : public ClusterBase +{ +public: + OnOffCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~OnOffCluster() {} +}; + +class DLL_EXPORT OnOffSwitchConfigurationCluster : public ClusterBase +{ +public: + OnOffSwitchConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~OnOffSwitchConfigurationCluster() {} +}; + +class DLL_EXPORT LevelControlCluster : public ClusterBase +{ +public: + LevelControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~LevelControlCluster() {} +}; + +class DLL_EXPORT BinaryInputBasicCluster : public ClusterBase +{ +public: + BinaryInputBasicCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~BinaryInputBasicCluster() {} +}; + +class DLL_EXPORT DescriptorCluster : public ClusterBase +{ +public: + DescriptorCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~DescriptorCluster() {} +}; + +class DLL_EXPORT BindingCluster : public ClusterBase +{ +public: + BindingCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~BindingCluster() {} +}; + +class DLL_EXPORT AccessControlCluster : public ClusterBase +{ +public: + AccessControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~AccessControlCluster() {} +}; + +class DLL_EXPORT ActionsCluster : public ClusterBase +{ +public: + ActionsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ActionsCluster() {} +}; + +class DLL_EXPORT BasicInformationCluster : public ClusterBase +{ +public: + BasicInformationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~BasicInformationCluster() {} +}; + +class DLL_EXPORT OtaSoftwareUpdateProviderCluster : public ClusterBase +{ +public: + OtaSoftwareUpdateProviderCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~OtaSoftwareUpdateProviderCluster() {} +}; + +class DLL_EXPORT OtaSoftwareUpdateRequestorCluster : public ClusterBase +{ +public: + OtaSoftwareUpdateRequestorCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~OtaSoftwareUpdateRequestorCluster() {} +}; + +class DLL_EXPORT LocalizationConfigurationCluster : public ClusterBase +{ +public: + LocalizationConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~LocalizationConfigurationCluster() {} +}; + +class DLL_EXPORT TimeFormatLocalizationCluster : public ClusterBase +{ +public: + TimeFormatLocalizationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~TimeFormatLocalizationCluster() {} +}; + +class DLL_EXPORT UnitLocalizationCluster : public ClusterBase +{ +public: + UnitLocalizationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~UnitLocalizationCluster() {} +}; + +class DLL_EXPORT PowerSourceConfigurationCluster : public ClusterBase +{ +public: + PowerSourceConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~PowerSourceConfigurationCluster() {} +}; + +class DLL_EXPORT PowerSourceCluster : public ClusterBase +{ +public: + PowerSourceCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~PowerSourceCluster() {} +}; + +class DLL_EXPORT GeneralCommissioningCluster : public ClusterBase +{ +public: + GeneralCommissioningCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~GeneralCommissioningCluster() {} +}; + +class DLL_EXPORT NetworkCommissioningCluster : public ClusterBase +{ +public: + NetworkCommissioningCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~NetworkCommissioningCluster() {} +}; + +class DLL_EXPORT DiagnosticLogsCluster : public ClusterBase +{ +public: + DiagnosticLogsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~DiagnosticLogsCluster() {} +}; + +class DLL_EXPORT GeneralDiagnosticsCluster : public ClusterBase +{ +public: + GeneralDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~GeneralDiagnosticsCluster() {} +}; + +class DLL_EXPORT SoftwareDiagnosticsCluster : public ClusterBase +{ +public: + SoftwareDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~SoftwareDiagnosticsCluster() {} +}; + +class DLL_EXPORT ThreadNetworkDiagnosticsCluster : public ClusterBase +{ +public: + ThreadNetworkDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ThreadNetworkDiagnosticsCluster() {} +}; + +class DLL_EXPORT WiFiNetworkDiagnosticsCluster : public ClusterBase +{ +public: + WiFiNetworkDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~WiFiNetworkDiagnosticsCluster() {} +}; + +class DLL_EXPORT EthernetNetworkDiagnosticsCluster : public ClusterBase +{ +public: + EthernetNetworkDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~EthernetNetworkDiagnosticsCluster() {} +}; + +class DLL_EXPORT TimeSynchronizationCluster : public ClusterBase +{ +public: + TimeSynchronizationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~TimeSynchronizationCluster() {} +}; + +class DLL_EXPORT BridgedDeviceBasicInformationCluster : public ClusterBase +{ +public: + BridgedDeviceBasicInformationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~BridgedDeviceBasicInformationCluster() {} +}; + +class DLL_EXPORT SwitchCluster : public ClusterBase +{ +public: + SwitchCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~SwitchCluster() {} +}; + +class DLL_EXPORT AdministratorCommissioningCluster : public ClusterBase +{ +public: + AdministratorCommissioningCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~AdministratorCommissioningCluster() {} +}; + +class DLL_EXPORT OperationalCredentialsCluster : public ClusterBase +{ +public: + OperationalCredentialsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~OperationalCredentialsCluster() {} +}; + +class DLL_EXPORT GroupKeyManagementCluster : public ClusterBase +{ +public: + GroupKeyManagementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~GroupKeyManagementCluster() {} +}; + +class DLL_EXPORT FixedLabelCluster : public ClusterBase +{ +public: + FixedLabelCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~FixedLabelCluster() {} +}; + +class DLL_EXPORT UserLabelCluster : public ClusterBase +{ +public: + UserLabelCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~UserLabelCluster() {} +}; + +class DLL_EXPORT BooleanStateCluster : public ClusterBase +{ +public: + BooleanStateCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~BooleanStateCluster() {} +}; + +class DLL_EXPORT IcdManagementCluster : public ClusterBase +{ +public: + IcdManagementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~IcdManagementCluster() {} +}; + +class DLL_EXPORT ModeSelectCluster : public ClusterBase +{ +public: + ModeSelectCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ModeSelectCluster() {} +}; + +class DLL_EXPORT RefrigeratorAlarmCluster : public ClusterBase +{ +public: + RefrigeratorAlarmCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~RefrigeratorAlarmCluster() {} +}; + +class DLL_EXPORT AirQualityCluster : public ClusterBase +{ +public: + AirQualityCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~AirQualityCluster() {} +}; + +class DLL_EXPORT SmokeCoAlarmCluster : public ClusterBase +{ +public: + SmokeCoAlarmCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~SmokeCoAlarmCluster() {} +}; + +class DLL_EXPORT HepaFilterMonitoringCluster : public ClusterBase +{ +public: + HepaFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~HepaFilterMonitoringCluster() {} +}; + +class DLL_EXPORT ActivatedCarbonFilterMonitoringCluster : public ClusterBase +{ +public: + ActivatedCarbonFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ActivatedCarbonFilterMonitoringCluster() {} +}; + +class DLL_EXPORT CeramicFilterMonitoringCluster : public ClusterBase +{ +public: + CeramicFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~CeramicFilterMonitoringCluster() {} +}; + +class DLL_EXPORT ElectrostaticFilterMonitoringCluster : public ClusterBase +{ +public: + ElectrostaticFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ElectrostaticFilterMonitoringCluster() {} +}; + +class DLL_EXPORT UvFilterMonitoringCluster : public ClusterBase +{ +public: + UvFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~UvFilterMonitoringCluster() {} +}; + +class DLL_EXPORT IonizingFilterMonitoringCluster : public ClusterBase +{ +public: + IonizingFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~IonizingFilterMonitoringCluster() {} +}; + +class DLL_EXPORT ZeoliteFilterMonitoringCluster : public ClusterBase +{ +public: + ZeoliteFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ZeoliteFilterMonitoringCluster() {} +}; + +class DLL_EXPORT OzoneFilterMonitoringCluster : public ClusterBase +{ +public: + OzoneFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~OzoneFilterMonitoringCluster() {} +}; + +class DLL_EXPORT WaterTankMonitoringCluster : public ClusterBase +{ +public: + WaterTankMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~WaterTankMonitoringCluster() {} +}; + +class DLL_EXPORT FuelTankMonitoringCluster : public ClusterBase +{ +public: + FuelTankMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~FuelTankMonitoringCluster() {} +}; + +class DLL_EXPORT InkCartridgeMonitoringCluster : public ClusterBase +{ +public: + InkCartridgeMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~InkCartridgeMonitoringCluster() {} +}; + +class DLL_EXPORT TonerCartridgeMonitoringCluster : public ClusterBase +{ +public: + TonerCartridgeMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~TonerCartridgeMonitoringCluster() {} +}; + +class DLL_EXPORT DoorLockCluster : public ClusterBase +{ +public: + DoorLockCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~DoorLockCluster() {} +}; + +class DLL_EXPORT WindowCoveringCluster : public ClusterBase +{ +public: + WindowCoveringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~WindowCoveringCluster() {} +}; + +class DLL_EXPORT BarrierControlCluster : public ClusterBase +{ +public: + BarrierControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~BarrierControlCluster() {} +}; + +class DLL_EXPORT PumpConfigurationAndControlCluster : public ClusterBase +{ +public: + PumpConfigurationAndControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~PumpConfigurationAndControlCluster() {} +}; + +class DLL_EXPORT ThermostatCluster : public ClusterBase +{ +public: + ThermostatCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ThermostatCluster() {} +}; + +class DLL_EXPORT FanControlCluster : public ClusterBase +{ +public: + FanControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~FanControlCluster() {} +}; + +class DLL_EXPORT ThermostatUserInterfaceConfigurationCluster : public ClusterBase +{ +public: + ThermostatUserInterfaceConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ThermostatUserInterfaceConfigurationCluster() {} +}; + +class DLL_EXPORT ColorControlCluster : public ClusterBase +{ +public: + ColorControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ColorControlCluster() {} +}; + +class DLL_EXPORT BallastConfigurationCluster : public ClusterBase +{ +public: + BallastConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~BallastConfigurationCluster() {} +}; + +class DLL_EXPORT IlluminanceMeasurementCluster : public ClusterBase +{ +public: + IlluminanceMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~IlluminanceMeasurementCluster() {} +}; + +class DLL_EXPORT TemperatureMeasurementCluster : public ClusterBase +{ +public: + TemperatureMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~TemperatureMeasurementCluster() {} +}; + +class DLL_EXPORT PressureMeasurementCluster : public ClusterBase +{ +public: + PressureMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~PressureMeasurementCluster() {} +}; + +class DLL_EXPORT FlowMeasurementCluster : public ClusterBase +{ +public: + FlowMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~FlowMeasurementCluster() {} +}; + +class DLL_EXPORT RelativeHumidityMeasurementCluster : public ClusterBase +{ +public: + RelativeHumidityMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~RelativeHumidityMeasurementCluster() {} +}; + +class DLL_EXPORT OccupancySensingCluster : public ClusterBase +{ +public: + OccupancySensingCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~OccupancySensingCluster() {} +}; + +class DLL_EXPORT WakeOnLanCluster : public ClusterBase +{ +public: + WakeOnLanCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~WakeOnLanCluster() {} +}; + +class DLL_EXPORT ChannelCluster : public ClusterBase +{ +public: + ChannelCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ChannelCluster() {} +}; + +class DLL_EXPORT TargetNavigatorCluster : public ClusterBase +{ +public: + TargetNavigatorCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~TargetNavigatorCluster() {} +}; + +class DLL_EXPORT MediaPlaybackCluster : public ClusterBase +{ +public: + MediaPlaybackCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~MediaPlaybackCluster() {} +}; + +class DLL_EXPORT MediaInputCluster : public ClusterBase +{ +public: + MediaInputCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~MediaInputCluster() {} +}; + +class DLL_EXPORT LowPowerCluster : public ClusterBase +{ +public: + LowPowerCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~LowPowerCluster() {} +}; + +class DLL_EXPORT KeypadInputCluster : public ClusterBase +{ +public: + KeypadInputCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~KeypadInputCluster() {} +}; + +class DLL_EXPORT ContentLauncherCluster : public ClusterBase +{ +public: + ContentLauncherCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ContentLauncherCluster() {} +}; + +class DLL_EXPORT AudioOutputCluster : public ClusterBase +{ +public: + AudioOutputCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~AudioOutputCluster() {} +}; + +class DLL_EXPORT ApplicationLauncherCluster : public ClusterBase +{ +public: + ApplicationLauncherCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ApplicationLauncherCluster() {} +}; + +class DLL_EXPORT ApplicationBasicCluster : public ClusterBase +{ +public: + ApplicationBasicCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ApplicationBasicCluster() {} +}; + +class DLL_EXPORT AccountLoginCluster : public ClusterBase +{ +public: + AccountLoginCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~AccountLoginCluster() {} +}; + +class DLL_EXPORT ElectricalMeasurementCluster : public ClusterBase +{ +public: + ElectricalMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~ElectricalMeasurementCluster() {} +}; + +class DLL_EXPORT UnitTestingCluster : public ClusterBase +{ +public: + UnitTestingCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~UnitTestingCluster() {} +}; + +} // namespace Controller +} // namespace chip diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h b/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h new file mode 100644 index 00000000000000..808f03ecdc01c9 --- /dev/null +++ b/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h @@ -0,0 +1,1200 @@ +/* + * + * 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 +#include + +// Default values for the attributes longer than a pointer, +// in a form of a binary blob +// Separate block is generated for big-endian and little-endian cases. +#if BIGENDIAN_CPU +#define GENERATED_DEFAULTS \ + {} + +#else // !BIGENDIAN_CPU +#define GENERATED_DEFAULTS \ + {} + +#endif // BIGENDIAN_CPU + +#define GENERATED_DEFAULTS_COUNT (0) + +// This is an array of EmberAfAttributeMinMaxValue structures. +#define GENERATED_MIN_MAX_DEFAULT_COUNT 0 +#define GENERATED_MIN_MAX_DEFAULTS \ + {} + +// This is an array of EmberAfAttributeMetadata structures. +#define GENERATED_ATTRIBUTE_COUNT 0 +#define GENERATED_ATTRIBUTES \ + {} + +// clang-format off +#define GENERATED_EVENT_COUNT 0 +#define GENERATED_EVENTS { \ +} + +// clang-format on + +// Cluster function static arrays +#define GENERATED_FUNCTION_ARRAYS + +// This is an array of EmberAfCluster structures. +#define GENERATED_CLUSTER_COUNT 82 +// clang-format off +#define GENERATED_CLUSTERS { \ + { \ + /* Endpoint: 1, Cluster: Identify (client) */ \ + .clusterId = 0x00000003, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Groups (client) */ \ + .clusterId = 0x00000004, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Scenes (client) */ \ + .clusterId = 0x00000005, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: On/Off (client) */ \ + .clusterId = 0x00000006, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: On/off Switch Configuration (client) */ \ + .clusterId = 0x00000007, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Level Control (client) */ \ + .clusterId = 0x00000008, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Binary Input (Basic) (client) */ \ + .clusterId = 0x0000000F, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Descriptor (client) */ \ + .clusterId = 0x0000001D, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Binding (client) */ \ + .clusterId = 0x0000001E, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Access Control (client) */ \ + .clusterId = 0x0000001F, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Actions (client) */ \ + .clusterId = 0x00000025, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Basic Information (client) */ \ + .clusterId = 0x00000028, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: OTA Software Update Provider (client) */ \ + .clusterId = 0x00000029, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: OTA Software Update Requestor (client) */ \ + .clusterId = 0x0000002A, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Localization Configuration (client) */ \ + .clusterId = 0x0000002B, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Time Format Localization (client) */ \ + .clusterId = 0x0000002C, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Unit Localization (client) */ \ + .clusterId = 0x0000002D, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Power Source Configuration (client) */ \ + .clusterId = 0x0000002E, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Power Source (client) */ \ + .clusterId = 0x0000002F, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: General Commissioning (client) */ \ + .clusterId = 0x00000030, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Network Commissioning (client) */ \ + .clusterId = 0x00000031, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Diagnostic Logs (client) */ \ + .clusterId = 0x00000032, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: General Diagnostics (client) */ \ + .clusterId = 0x00000033, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Software Diagnostics (client) */ \ + .clusterId = 0x00000034, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Thread Network Diagnostics (client) */ \ + .clusterId = 0x00000035, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: WiFi Network Diagnostics (client) */ \ + .clusterId = 0x00000036, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Ethernet Network Diagnostics (client) */ \ + .clusterId = 0x00000037, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Time Synchronization (client) */ \ + .clusterId = 0x00000038, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Bridged Device Basic Information (client) */ \ + .clusterId = 0x00000039, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Switch (client) */ \ + .clusterId = 0x0000003B, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Administrator Commissioning (client) */ \ + .clusterId = 0x0000003C, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Operational Credentials (client) */ \ + .clusterId = 0x0000003E, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Group Key Management (client) */ \ + .clusterId = 0x0000003F, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Fixed Label (client) */ \ + .clusterId = 0x00000040, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: User Label (client) */ \ + .clusterId = 0x00000041, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Boolean State (client) */ \ + .clusterId = 0x00000045, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: ICD Management (client) */ \ + .clusterId = 0x00000046, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Mode Select (client) */ \ + .clusterId = 0x00000050, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Refrigerator Alarm (client) */ \ + .clusterId = 0x00000057, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Air Quality (client) */ \ + .clusterId = 0x0000005B, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Smoke CO Alarm (client) */ \ + .clusterId = 0x0000005C, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: HEPA Filter Monitoring (client) */ \ + .clusterId = 0x00000071, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Activated Carbon Filter Monitoring (client) */ \ + .clusterId = 0x00000072, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Ceramic Filter Monitoring (client) */ \ + .clusterId = 0x00000073, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Electrostatic Filter Monitoring (client) */ \ + .clusterId = 0x00000074, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: UV Filter Monitoring (client) */ \ + .clusterId = 0x00000075, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Ionizing Filter Monitoring (client) */ \ + .clusterId = 0x00000076, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Zeolite Filter Monitoring (client) */ \ + .clusterId = 0x00000077, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Ozone Filter Monitoring (client) */ \ + .clusterId = 0x00000078, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Water Tank Monitoring (client) */ \ + .clusterId = 0x00000079, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Fuel Tank Monitoring (client) */ \ + .clusterId = 0x0000007A, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Ink Cartridge Monitoring (client) */ \ + .clusterId = 0x0000007B, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Toner Cartridge Monitoring (client) */ \ + .clusterId = 0x0000007C, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Door Lock (client) */ \ + .clusterId = 0x00000101, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Window Covering (client) */ \ + .clusterId = 0x00000102, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Barrier Control (client) */ \ + .clusterId = 0x00000103, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Pump Configuration and Control (client) */ \ + .clusterId = 0x00000200, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Thermostat (client) */ \ + .clusterId = 0x00000201, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Fan Control (client) */ \ + .clusterId = 0x00000202, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Thermostat User Interface Configuration (client) */ \ + .clusterId = 0x00000204, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Color Control (client) */ \ + .clusterId = 0x00000300, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Ballast Configuration (client) */ \ + .clusterId = 0x00000301, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Illuminance Measurement (client) */ \ + .clusterId = 0x00000400, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Temperature Measurement (client) */ \ + .clusterId = 0x00000402, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Pressure Measurement (client) */ \ + .clusterId = 0x00000403, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Flow Measurement (client) */ \ + .clusterId = 0x00000404, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Relative Humidity Measurement (client) */ \ + .clusterId = 0x00000405, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Occupancy Sensing (client) */ \ + .clusterId = 0x00000406, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Wake on LAN (client) */ \ + .clusterId = 0x00000503, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Channel (client) */ \ + .clusterId = 0x00000504, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Target Navigator (client) */ \ + .clusterId = 0x00000505, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Media Playback (client) */ \ + .clusterId = 0x00000506, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Media Input (client) */ \ + .clusterId = 0x00000507, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Low Power (client) */ \ + .clusterId = 0x00000508, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Keypad Input (client) */ \ + .clusterId = 0x00000509, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Content Launcher (client) */ \ + .clusterId = 0x0000050A, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Audio Output (client) */ \ + .clusterId = 0x0000050B, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Application Launcher (client) */ \ + .clusterId = 0x0000050C, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Application Basic (client) */ \ + .clusterId = 0x0000050D, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Account Login (client) */ \ + .clusterId = 0x0000050E, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Electrical Measurement (client) */ \ + .clusterId = 0x00000B04, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ + { \ + /* Endpoint: 1, Cluster: Unit Testing (client) */ \ + .clusterId = 0xFFF1FC05, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ +} + +// clang-format on + +#define ZAP_FIXED_ENDPOINT_DATA_VERSION_COUNT 0 + +// This is an array of EmberAfEndpointType structures. +#define GENERATED_ENDPOINT_TYPES \ + { \ + { ZAP_CLUSTER_INDEX(0), 82, 0 }, \ + } + +// Largest attribute size is needed for various buffers +#define ATTRIBUTE_LARGEST (1) + +static_assert(ATTRIBUTE_LARGEST <= CHIP_CONFIG_MAX_ATTRIBUTE_STORE_ELEMENT_SIZE, "ATTRIBUTE_LARGEST larger than expected"); + +// Total size of singleton attributes +#define ATTRIBUTE_SINGLETONS_SIZE (0) + +// Total size of attribute storage +#define ATTRIBUTE_MAX_SIZE (0) + +// Number of fixed endpoints +#define FIXED_ENDPOINT_COUNT (1) + +// Array of endpoints that are supported, the data inside +// the array is the endpoint number. +#define FIXED_ENDPOINT_ARRAY \ + { \ + 0x0001 \ + } + +// Array of profile ids +#define FIXED_PROFILE_IDS \ + { \ + 0x0103 \ + } + +// Array of device types +#define FIXED_DEVICE_TYPES \ + { \ + { \ + 0x0016, 1 \ + } \ + } + +// Array of device type offsets +#define FIXED_DEVICE_TYPE_OFFSETS \ + { \ + 0 \ + } + +// Array of device type lengths +#define FIXED_DEVICE_TYPE_LENGTHS \ + { \ + 1 \ + } + +// Array of endpoint types supported on each endpoint +#define FIXED_ENDPOINT_TYPES \ + { \ + 0 \ + } + +// Array of networks supported on each endpoint +#define FIXED_NETWORKS \ + { \ + 0 \ + } diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h b/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h new file mode 100644 index 00000000000000..7c99c653a14162 --- /dev/null +++ b/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h @@ -0,0 +1,435 @@ +/* + * + * 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 + +/**** Cluster endpoint counts ****/ +#define EMBER_AF_IDENTIFY_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_GROUPS_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_SCENES_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ON_OFF_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ON_OFF_SWITCH_CONFIGURATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_LEVEL_CONTROL_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_BINARY_INPUT_BASIC_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_DESCRIPTOR_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_BINDING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ACCESS_CONTROL_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ACTIONS_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_BASIC_INFORMATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_OTA_SOFTWARE_UPDATE_PROVIDER_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_OTA_SOFTWARE_UPDATE_REQUESTOR_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_LOCALIZATION_CONFIGURATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_TIME_FORMAT_LOCALIZATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_UNIT_LOCALIZATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_POWER_SOURCE_CONFIGURATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_POWER_SOURCE_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_GENERAL_COMMISSIONING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_NETWORK_COMMISSIONING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_DIAGNOSTIC_LOGS_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_GENERAL_DIAGNOSTICS_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_SOFTWARE_DIAGNOSTICS_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_THREAD_NETWORK_DIAGNOSTICS_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_WIFI_NETWORK_DIAGNOSTICS_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ETHERNET_NETWORK_DIAGNOSTICS_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_TIME_SYNCHRONIZATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_BRIDGED_DEVICE_BASIC_INFORMATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_SWITCH_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ADMINISTRATOR_COMMISSIONING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_OPERATIONAL_CREDENTIALS_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_GROUP_KEY_MANAGEMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_FIXED_LABEL_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_USER_LABEL_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_BOOLEAN_STATE_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ICD_MANAGEMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_MODE_SELECT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_REFRIGERATOR_ALARM_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_AIR_QUALITY_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_SMOKE_CO_ALARM_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_HEPA_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_CERAMIC_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ELECTROSTATIC_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_UV_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_IONIZING_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ZEOLITE_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_OZONE_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_WATER_TANK_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_FUEL_TANK_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_INK_CARTRIDGE_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_TONER_CARTRIDGE_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_DOOR_LOCK_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_WINDOW_COVERING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_BARRIER_CONTROL_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_PUMP_CONFIGURATION_AND_CONTROL_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_THERMOSTAT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_FAN_CONTROL_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_COLOR_CONTROL_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_BALLAST_CONFIGURATION_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ILLUMINANCE_MEASUREMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_TEMPERATURE_MEASUREMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_PRESSURE_MEASUREMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_FLOW_MEASUREMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_OCCUPANCY_SENSING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_WAKE_ON_LAN_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_CHANNEL_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_TARGET_NAVIGATOR_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_MEDIA_PLAYBACK_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_MEDIA_INPUT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_LOW_POWER_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_KEYPAD_INPUT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_CONTENT_LAUNCHER_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_AUDIO_OUTPUT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_APPLICATION_LAUNCHER_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_APPLICATION_BASIC_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ACCOUNT_LOGIN_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_ELECTRICAL_MEASUREMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_UNIT_TESTING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) + +/**** Cluster Plugins ****/ + +// Use this macro to check if the client side of the Identify cluster is included +#define ZCL_USING_IDENTIFY_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_IDENTIFY_CLIENT + +// Use this macro to check if the client side of the Groups cluster is included +#define ZCL_USING_GROUPS_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_GROUPS_CLIENT + +// Use this macro to check if the client side of the Scenes cluster is included +#define ZCL_USING_SCENES_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_SCENES_CLIENT + +// Use this macro to check if the client side of the On/Off cluster is included +#define ZCL_USING_ON_OFF_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ON_OFF_CLIENT + +// Use this macro to check if the client side of the On/off Switch Configuration cluster is included +#define ZCL_USING_ON_OFF_SWITCH_CONFIGURATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ON_OFF_SWITCH_CONFIGURATION_CLIENT + +// Use this macro to check if the client side of the Level Control cluster is included +#define ZCL_USING_LEVEL_CONTROL_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_LEVEL_CONTROL_CLIENT + +// Use this macro to check if the client side of the Binary Input (Basic) cluster is included +#define ZCL_USING_BINARY_INPUT_BASIC_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_BINARY_INPUT_BASIC_CLIENT + +// Use this macro to check if the client side of the Descriptor cluster is included +#define ZCL_USING_DESCRIPTOR_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_DESCRIPTOR_CLIENT + +// Use this macro to check if the client side of the Binding cluster is included +#define ZCL_USING_BINDING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_BINDING_CLIENT + +// Use this macro to check if the client side of the Access Control cluster is included +#define ZCL_USING_ACCESS_CONTROL_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ACCESS_CONTROL_CLIENT + +// Use this macro to check if the client side of the Actions cluster is included +#define ZCL_USING_ACTIONS_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ACTIONS_CLIENT + +// Use this macro to check if the client side of the Basic Information cluster is included +#define ZCL_USING_BASIC_INFORMATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_BASIC_INFORMATION_CLIENT + +// Use this macro to check if the client side of the OTA Software Update Provider cluster is included +#define ZCL_USING_OTA_SOFTWARE_UPDATE_PROVIDER_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_OTA_SOFTWARE_UPDATE_PROVIDER_CLIENT + +// Use this macro to check if the client side of the OTA Software Update Requestor cluster is included +#define ZCL_USING_OTA_SOFTWARE_UPDATE_REQUESTOR_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_OTA_SOFTWARE_UPDATE_REQUESTOR_CLIENT + +// Use this macro to check if the client side of the Localization Configuration cluster is included +#define ZCL_USING_LOCALIZATION_CONFIGURATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_LOCALIZATION_CONFIGURATION_CLIENT + +// Use this macro to check if the client side of the Time Format Localization cluster is included +#define ZCL_USING_TIME_FORMAT_LOCALIZATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_TIME_FORMAT_LOCALIZATION_CLIENT + +// Use this macro to check if the client side of the Unit Localization cluster is included +#define ZCL_USING_UNIT_LOCALIZATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_UNIT_LOCALIZATION_CLIENT + +// Use this macro to check if the client side of the Power Source Configuration cluster is included +#define ZCL_USING_POWER_SOURCE_CONFIGURATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_POWER_SOURCE_CONFIGURATION_CLIENT + +// Use this macro to check if the client side of the Power Source cluster is included +#define ZCL_USING_POWER_SOURCE_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_POWER_SOURCE_CLIENT + +// Use this macro to check if the client side of the General Commissioning cluster is included +#define ZCL_USING_GENERAL_COMMISSIONING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_GENERAL_COMMISSIONING_CLIENT + +// Use this macro to check if the client side of the Network Commissioning cluster is included +#define ZCL_USING_NETWORK_COMMISSIONING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_NETWORK_COMMISSIONING_CLIENT + +// Use this macro to check if the client side of the Diagnostic Logs cluster is included +#define ZCL_USING_DIAGNOSTIC_LOGS_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_DIAGNOSTIC_LOGS_CLIENT + +// Use this macro to check if the client side of the General Diagnostics cluster is included +#define ZCL_USING_GENERAL_DIAGNOSTICS_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_GENERAL_DIAGNOSTICS_CLIENT + +// Use this macro to check if the client side of the Software Diagnostics cluster is included +#define ZCL_USING_SOFTWARE_DIAGNOSTICS_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_SOFTWARE_DIAGNOSTICS_CLIENT + +// Use this macro to check if the client side of the Thread Network Diagnostics cluster is included +#define ZCL_USING_THREAD_NETWORK_DIAGNOSTICS_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_THREAD_NETWORK_DIAGNOSTICS_CLIENT + +// Use this macro to check if the client side of the WiFi Network Diagnostics cluster is included +#define ZCL_USING_WIFI_NETWORK_DIAGNOSTICS_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_WI_FI_NETWORK_DIAGNOSTICS_CLIENT + +// Use this macro to check if the client side of the Ethernet Network Diagnostics cluster is included +#define ZCL_USING_ETHERNET_NETWORK_DIAGNOSTICS_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ETHERNET_NETWORK_DIAGNOSTICS_CLIENT + +// Use this macro to check if the client side of the Time Synchronization cluster is included +#define ZCL_USING_TIME_SYNCHRONIZATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_TIME_SYNCHRONIZATION_CLIENT + +// Use this macro to check if the client side of the Bridged Device Basic Information cluster is included +#define ZCL_USING_BRIDGED_DEVICE_BASIC_INFORMATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_BRIDGED_DEVICE_BASIC_INFORMATION_CLIENT + +// Use this macro to check if the client side of the Switch cluster is included +#define ZCL_USING_SWITCH_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_SWITCH_CLIENT + +// Use this macro to check if the client side of the Administrator Commissioning cluster is included +#define ZCL_USING_ADMINISTRATOR_COMMISSIONING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ADMINISTRATOR_COMMISSIONING_CLIENT + +// Use this macro to check if the client side of the Operational Credentials cluster is included +#define ZCL_USING_OPERATIONAL_CREDENTIALS_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_OPERATIONAL_CREDENTIALS_CLIENT + +// Use this macro to check if the client side of the Group Key Management cluster is included +#define ZCL_USING_GROUP_KEY_MANAGEMENT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_GROUP_KEY_MANAGEMENT_CLIENT + +// Use this macro to check if the client side of the Fixed Label cluster is included +#define ZCL_USING_FIXED_LABEL_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_FIXED_LABEL_CLIENT + +// Use this macro to check if the client side of the User Label cluster is included +#define ZCL_USING_USER_LABEL_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_USER_LABEL_CLIENT + +// Use this macro to check if the client side of the Boolean State cluster is included +#define ZCL_USING_BOOLEAN_STATE_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_BOOLEAN_STATE_CLIENT + +// Use this macro to check if the client side of the ICD Management cluster is included +#define ZCL_USING_ICD_MANAGEMENT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ICD_MANAGEMENT_CLIENT + +// Use this macro to check if the client side of the Mode Select cluster is included +#define ZCL_USING_MODE_SELECT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_MODE_SELECT_CLIENT + +// Use this macro to check if the client side of the Refrigerator Alarm cluster is included +#define ZCL_USING_REFRIGERATOR_ALARM_CLIENT +#define EMBER_AF_PLUGIN_REFRIGERATOR_ALARM_CLIENT + +// Use this macro to check if the client side of the Air Quality cluster is included +#define ZCL_USING_AIR_QUALITY_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_AIR_QUALITY_CLIENT + +// Use this macro to check if the client side of the Smoke CO Alarm cluster is included +#define ZCL_USING_SMOKE_CO_ALARM_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_SMOKE_CO_ALARM_CLIENT + +// Use this macro to check if the client side of the HEPA Filter Monitoring cluster is included +#define ZCL_USING_HEPA_FILTER_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_HEPA_FILTER_MONITORING_CLIENT + +// Use this macro to check if the client side of the Activated Carbon Filter Monitoring cluster is included +#define ZCL_USING_ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ACTIVATED_CARBON_FILTER_MONITORING_CLIENT + +// Use this macro to check if the client side of the Ceramic Filter Monitoring cluster is included +#define ZCL_USING_CERAMIC_FILTER_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_CERAMIC_FILTER_MONITORING_CLIENT + +// Use this macro to check if the client side of the Electrostatic Filter Monitoring cluster is included +#define ZCL_USING_ELECTROSTATIC_FILTER_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ELECTROSTATIC_FILTER_MONITORING_CLIENT + +// Use this macro to check if the client side of the UV Filter Monitoring cluster is included +#define ZCL_USING_UV_FILTER_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_UV_FILTER_MONITORING_CLIENT + +// Use this macro to check if the client side of the Ionizing Filter Monitoring cluster is included +#define ZCL_USING_IONIZING_FILTER_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_IONIZING_FILTER_MONITORING_CLIENT + +// Use this macro to check if the client side of the Zeolite Filter Monitoring cluster is included +#define ZCL_USING_ZEOLITE_FILTER_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ZEOLITE_FILTER_MONITORING_CLIENT + +// Use this macro to check if the client side of the Ozone Filter Monitoring cluster is included +#define ZCL_USING_OZONE_FILTER_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_OZONE_FILTER_MONITORING_CLIENT + +// Use this macro to check if the client side of the Water Tank Monitoring cluster is included +#define ZCL_USING_WATER_TANK_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_WATER_TANK_MONITORING_CLIENT + +// Use this macro to check if the client side of the Fuel Tank Monitoring cluster is included +#define ZCL_USING_FUEL_TANK_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_FUEL_TANK_MONITORING_CLIENT + +// Use this macro to check if the client side of the Ink Cartridge Monitoring cluster is included +#define ZCL_USING_INK_CARTRIDGE_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_INK_CARTRIDGE_MONITORING_CLIENT + +// Use this macro to check if the client side of the Toner Cartridge Monitoring cluster is included +#define ZCL_USING_TONER_CARTRIDGE_MONITORING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_TONER_CARTRIDGE_MONITORING_CLIENT + +// Use this macro to check if the client side of the Door Lock cluster is included +#define ZCL_USING_DOOR_LOCK_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_DOOR_LOCK_CLIENT + +// Use this macro to check if the client side of the Window Covering cluster is included +#define ZCL_USING_WINDOW_COVERING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_WINDOW_COVERING_CLIENT + +// Use this macro to check if the client side of the Barrier Control cluster is included +#define ZCL_USING_BARRIER_CONTROL_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_BARRIER_CONTROL_CLIENT + +// Use this macro to check if the client side of the Pump Configuration and Control cluster is included +#define ZCL_USING_PUMP_CONFIGURATION_AND_CONTROL_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_PUMP_CONFIGURATION_AND_CONTROL_CLIENT + +// Use this macro to check if the client side of the Thermostat cluster is included +#define ZCL_USING_THERMOSTAT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_THERMOSTAT_CLIENT + +// Use this macro to check if the client side of the Fan Control cluster is included +#define ZCL_USING_FAN_CONTROL_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_FAN_CONTROL_CLIENT + +// Use this macro to check if the client side of the Thermostat User Interface Configuration cluster is included +#define ZCL_USING_THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLIENT + +// Use this macro to check if the client side of the Color Control cluster is included +#define ZCL_USING_COLOR_CONTROL_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_COLOR_CONTROL_CLIENT + +// Use this macro to check if the client side of the Ballast Configuration cluster is included +#define ZCL_USING_BALLAST_CONFIGURATION_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_BALLAST_CONFIGURATION_CLIENT + +// Use this macro to check if the client side of the Illuminance Measurement cluster is included +#define ZCL_USING_ILLUMINANCE_MEASUREMENT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ILLUMINANCE_MEASUREMENT_CLIENT + +// Use this macro to check if the client side of the Temperature Measurement cluster is included +#define ZCL_USING_TEMPERATURE_MEASUREMENT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_CLIENT + +// Use this macro to check if the client side of the Pressure Measurement cluster is included +#define ZCL_USING_PRESSURE_MEASUREMENT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_PRESSURE_MEASUREMENT_CLIENT + +// Use this macro to check if the client side of the Flow Measurement cluster is included +#define ZCL_USING_FLOW_MEASUREMENT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_FLOW_MEASUREMENT_CLIENT + +// Use this macro to check if the client side of the Relative Humidity Measurement cluster is included +#define ZCL_USING_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_RELATIVE_HUMIDITY_MEASUREMENT_CLIENT + +// Use this macro to check if the client side of the Occupancy Sensing cluster is included +#define ZCL_USING_OCCUPANCY_SENSING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_OCCUPANCY_SENSING_CLIENT + +// Use this macro to check if the client side of the Wake on LAN cluster is included +#define ZCL_USING_WAKE_ON_LAN_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_WAKE_ON_LAN_CLIENT + +// Use this macro to check if the client side of the Channel cluster is included +#define ZCL_USING_CHANNEL_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_CHANNEL_CLIENT + +// Use this macro to check if the client side of the Target Navigator cluster is included +#define ZCL_USING_TARGET_NAVIGATOR_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_TARGET_NAVIGATOR_CLIENT + +// Use this macro to check if the client side of the Media Playback cluster is included +#define ZCL_USING_MEDIA_PLAYBACK_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_MEDIA_PLAYBACK_CLIENT + +// Use this macro to check if the client side of the Media Input cluster is included +#define ZCL_USING_MEDIA_INPUT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_MEDIA_INPUT_CLIENT + +// Use this macro to check if the client side of the Low Power cluster is included +#define ZCL_USING_LOW_POWER_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_LOW_POWER_CLIENT + +// Use this macro to check if the client side of the Keypad Input cluster is included +#define ZCL_USING_KEYPAD_INPUT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_KEYPAD_INPUT_CLIENT + +// Use this macro to check if the client side of the Content Launcher cluster is included +#define ZCL_USING_CONTENT_LAUNCHER_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_CONTENT_LAUNCHER_CLIENT + +// Use this macro to check if the client side of the Audio Output cluster is included +#define ZCL_USING_AUDIO_OUTPUT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_AUDIO_OUTPUT_CLIENT + +// Use this macro to check if the client side of the Application Launcher cluster is included +#define ZCL_USING_APPLICATION_LAUNCHER_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_APPLICATION_LAUNCHER_CLIENT + +// Use this macro to check if the client side of the Application Basic cluster is included +#define ZCL_USING_APPLICATION_BASIC_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_APPLICATION_BASIC_CLIENT + +// Use this macro to check if the client side of the Account Login cluster is included +#define ZCL_USING_ACCOUNT_LOGIN_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ACCOUNT_LOGIN_CLIENT + +// Use this macro to check if the client side of the Electrical Measurement cluster is included +#define ZCL_USING_ELECTRICAL_MEASUREMENT_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_ELECTRICAL_MEASUREMENT_CLIENT + +// Use this macro to check if the client side of the Unit Testing cluster is included +#define ZCL_USING_UNIT_TESTING_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_UNIT_TESTING_CLIENT