diff --git a/src/android/CHIPTool/.idea/runConfigurations.xml b/src/android/CHIPTool/.idea/runConfigurations.xml new file mode 100644 index 00000000000000..7f68460d8b38ac --- /dev/null +++ b/src/android/CHIPTool/.idea/runConfigurations.xml @@ -0,0 +1,12 @@ + + + + + + \ No newline at end of file diff --git a/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/clusterinteraction/ClusterDetailFragment.kt b/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/clusterinteraction/ClusterDetailFragment.kt index bb8def19a7e2c0..268841a7cf95e3 100644 --- a/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/clusterinteraction/ClusterDetailFragment.kt +++ b/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/clusterinteraction/ClusterDetailFragment.kt @@ -15,7 +15,7 @@ import androidx.core.view.forEach import androidx.fragment.app.Fragment import chip.clusterinfo.ClusterCommandCallback import chip.clusterinfo.ClusterInfo -import chip.clusterinfo.CommandInfo +import chip.clusterinfo.InteractionInfo import chip.clusterinfo.CommandResponseInfo import chip.clusterinfo.DelegatedClusterCallback import chip.devicecontroller.ChipClusters @@ -53,7 +53,7 @@ class ClusterDetailFragment : Fragment() { private lateinit var selectedClusterInfo: ClusterInfo private lateinit var selectedCluster: ChipClusters.BaseChipCluster private lateinit var selectedCommandCallback: DelegatedClusterCallback - private lateinit var selectedCommandInfo: CommandInfo + private lateinit var selectedInteractionInfo: InteractionInfo private var devicePtr = 0L private var endpointId = 0 @@ -80,12 +80,12 @@ class ClusterDetailFragment : Fragment() { val commandArguments = HashMap() parameterList.forEach { val type = - selectedCommandInfo.commandParameters[it.clusterParameterNameTv.text.toString()]!!.type + selectedInteractionInfo.commandParameters[it.clusterParameterNameTv.text.toString()]!!.type val data = castStringToType(it.clusterParameterData.text.toString(), type)!! commandArguments[it.clusterParameterNameTv.text.toString()] = data } - selectedCommandInfo.getCommandFunction() + selectedInteractionInfo.getCommandFunction() .invokeCommand(selectedCluster, selectedCommandCallback, commandArguments) } } @@ -94,7 +94,6 @@ class ClusterDetailFragment : Fragment() { private fun castStringToType(data: String, type: Class<*>): Any? { return when (type) { Int::class.java -> data.toInt() - String::class.java -> data Boolean::class.java -> data.toBoolean() else -> data } @@ -141,8 +140,8 @@ class ClusterDetailFragment : Fragment() { callbackList.removeAllViews() selectedCluster = selectedClusterInfo.createClusterFunction.create(devicePtr, endpointId) val selectedCommand: String = commandAutoComplete.adapter.getItem(position).toString() - selectedCommandInfo = selectedClusterInfo.commands[selectedCommand]!! - selectedCommandCallback = selectedCommandInfo.commandCallbackSupplier.get() + selectedInteractionInfo = selectedClusterInfo.commands[selectedCommand]!! + selectedCommandCallback = selectedInteractionInfo.commandCallbackSupplier.get() populateCommandParameter(inflater, parameterList) selectedCommandCallback.setCallbackDelegate(object : ClusterCommandCallback { override fun onSuccess(responseValues: Map) { @@ -167,7 +166,7 @@ class ClusterDetailFragment : Fragment() { } private fun populateCommandParameter(inflater: LayoutInflater, parameterList: LinearLayout) { - selectedCommandInfo.commandParameters.forEach { (paramName, paramInfo) -> + selectedInteractionInfo.commandParameters.forEach { (paramName, paramInfo) -> val param = inflater.inflate(R.layout.cluster_parameter_item, null, false) as ConstraintLayout param.clusterParameterNameTv.text = "${paramName}" param.clusterParameterTypeTv.text = "${paramInfo.type}" @@ -182,37 +181,55 @@ class ClusterDetailFragment : Fragment() { ) { responseValues.forEach { (variableNameType, response) -> if (response is List<*>) { - if (response.size == 0) { - val emptyCallback = - inflater.inflate(R.layout.cluster_callback_item, null, false) as ConstraintLayout - emptyCallback.clusterCallbackNameTv.text = "Result is empty" - callbackList.addView(emptyCallback) - } else { - response.forEachIndexed { index, it -> - val objectCallback = - inflater.inflate(R.layout.cluster_callback_item, null, false) as ConstraintLayout - objectCallback.clusterCallbackNameTv.text = variableNameType.name + "[$index]" - val objectDeserializationString = it.toString() - val callbackClassName = it!!.javaClass.toString().split('$').last() - objectCallback.clusterCallbackDataTv.text = callbackClassName - objectCallback.clusterCallbackDataTv.setOnClickListener { - AlertDialog.Builder(requireContext()) - .setTitle(callbackClassName) - .setMessage(objectDeserializationString) - .create() - .show() - } - objectCallback.clusterCallbackTypeTv.text = "List<$callbackClassName>" - callbackList.addView(objectCallback) - } - } + createListReadAttributeView(response, inflater, callbackList, variableNameType) } else { - val callback = + createBasicReadAttributeView(response, inflater, callbackList, variableNameType) + } + } + } + + private fun createBasicReadAttributeView( + response: Any, + inflater: LayoutInflater, + callbackList: LinearLayout, + variableNameType: CommandResponseInfo + ) { + val callbackItem = + inflater.inflate(R.layout.cluster_callback_item, null, false) as ConstraintLayout + callbackItem.clusterCallbackNameTv.text = variableNameType.name + callbackItem.clusterCallbackDataTv.text = response.toString() + callbackItem.clusterCallbackTypeTv.text = variableNameType.type + callbackList.addView(callbackItem) + } + + private fun createListReadAttributeView( + response: List<*>, + inflater: LayoutInflater, + callbackList: LinearLayout, + variableNameType: CommandResponseInfo + ) { + if (response.isEmpty()) { + val emptyCallback = + inflater.inflate(R.layout.cluster_callback_item, null, false) as ConstraintLayout + emptyCallback.clusterCallbackNameTv.text = "Result is empty" + callbackList.addView(emptyCallback) + } else { + response.forEachIndexed { index, it -> + val readAttributeCallbackItem = inflater.inflate(R.layout.cluster_callback_item, null, false) as ConstraintLayout - callback.clusterCallbackNameTv.text = variableNameType.name - callback.clusterCallbackDataTv.text = response.toString() - callback.clusterCallbackTypeTv.text = variableNameType.type - callbackList.addView(callback) + readAttributeCallbackItem.clusterCallbackNameTv.text = variableNameType.name + "[$index]" + val objectString = it.toString() + val callbackClassName = it!!.javaClass.toString().split('$').last() + readAttributeCallbackItem.clusterCallbackDataTv.text = callbackClassName + readAttributeCallbackItem.clusterCallbackDataTv.setOnClickListener { + AlertDialog.Builder(requireContext()) + .setTitle(callbackClassName) + .setMessage(objectString) + .create() + .show() + } + readAttributeCallbackItem.clusterCallbackTypeTv.text = "List<$callbackClassName>" + callbackList.addView(readAttributeCallbackItem) } } } diff --git a/src/controller/java/BUILD.gn b/src/controller/java/BUILD.gn index 31fafee2743e64..6a1efd413ca8ea 100644 --- a/src/controller/java/BUILD.gn +++ b/src/controller/java/BUILD.gn @@ -69,10 +69,10 @@ android_library("java") { sources = [ "src/chip/clusterinfo/ClusterCommandCallback.java", "src/chip/clusterinfo/ClusterInfo.java", - "src/chip/clusterinfo/CommandInfo.java", "src/chip/clusterinfo/CommandParameterInfo.java", "src/chip/clusterinfo/CommandResponseInfo.java", "src/chip/clusterinfo/DelegatedClusterCallback.java", + "src/chip/clusterinfo/InteractionInfo.java", "src/chip/devicecontroller/ChipClusterException.java", "src/chip/devicecontroller/ChipCommandType.java", "src/chip/devicecontroller/ChipDeviceController.java", diff --git a/src/controller/java/src/chip/clusterinfo/ClusterInfo.java b/src/controller/java/src/chip/clusterinfo/ClusterInfo.java index cb4dee857cceb8..efd37f150dae5f 100644 --- a/src/controller/java/src/chip/clusterinfo/ClusterInfo.java +++ b/src/controller/java/src/chip/clusterinfo/ClusterInfo.java @@ -6,9 +6,10 @@ /** ClusterInfo maps commands and provides a constructor function for a cluster. */ public class ClusterInfo { private final ClusterConstructor createClusterFunction; - private final Map commands; + private final Map commands; - public ClusterInfo(ClusterConstructor createClusterFunction, Map commands) { + public ClusterInfo( + ClusterConstructor createClusterFunction, Map commands) { this.createClusterFunction = createClusterFunction; this.commands = commands; } @@ -17,11 +18,11 @@ public ClusterConstructor getCreateClusterFunction() { return createClusterFunction; } - public Map getCommands() { + public Map getCommands() { return commands; } - public void combineCommands(Map newCommands) { + public void combineCommands(Map newCommands) { this.commands.putAll(newCommands); } diff --git a/src/controller/java/src/chip/clusterinfo/CommandInfo.java b/src/controller/java/src/chip/clusterinfo/InteractionInfo.java similarity index 83% rename from src/controller/java/src/chip/clusterinfo/CommandInfo.java rename to src/controller/java/src/chip/clusterinfo/InteractionInfo.java index 7bc59c1571ff88..c389cbb33c9812 100644 --- a/src/controller/java/src/chip/clusterinfo/CommandInfo.java +++ b/src/controller/java/src/chip/clusterinfo/InteractionInfo.java @@ -5,16 +5,16 @@ import java.util.function.Supplier; /** - * CommandInfo has a functional interface to invoke arbitrary commands based on cluster, callback - * and a map of arguments, a Supplier that provides {@link DelegatedClusterCallback}, and maps the - * parameter and commandParametersInfo. + * InteractionInfo has a functional interface to invoke arbitrary interaction based on cluster, + * callback and a map of arguments, a Supplier that provides {@link DelegatedClusterCallback}, and + * maps the parameter and commandParametersInfo. */ -public class CommandInfo { +public class InteractionInfo { public ClusterCommandFunction commandFunction; private Supplier commandCallbackSupplier; private Map commandParameters; - public CommandInfo( + public InteractionInfo( ClusterCommandFunction commandFunction, Supplier commandCallbackSupplier, Map commandParameters) { diff --git a/src/controller/java/templates/ChipClusters-java.zapt b/src/controller/java/templates/ChipClusters-java.zapt index a8949a104cbb91..6949da07b66c68 100644 --- a/src/controller/java/templates/ChipClusters-java.zapt +++ b/src/controller/java/templates/ChipClusters-java.zapt @@ -5,6 +5,7 @@ package chip.devicecontroller; import androidx.annotation.Nullable; import java.util.List; +import java.util.Arrays; import java.util.Optional; public class ChipClusters { @@ -179,18 +180,9 @@ public class ChipClusters { {{else if isStruct}} {{! TODO: Add support for structs here }} {{else if (isOctetString type)}} - output.append("byte[] {{asLowerCamelCase name}}: ["); - for (int i = 0; i < {{asLowerCamelCase name}}.length; i++) { - if (i != {{asLowerCamelCase name}}.length - 1) { - output.append({{asLowerCamelCase name}}[i]); - output.append(", "); - } - else { - output.append({{asLowerCamelCase name}}[i]); - output.append("]"); - output.append("\n"); - } - } + output.append("byte[] "); + output.append(Arrays.toString({{asLowerCamelCase name}})); + output.append("\n"); {{else if (isCharString type)}} output.append("String {{asLowerCamelCase name}}: "); output.append(this.{{asLowerCamelCase name}}); diff --git a/src/controller/java/templates/ClusterInfo-java.zapt b/src/controller/java/templates/ClusterInfo-java.zapt index 0270c88a27217f..252fc7528cd765 100644 --- a/src/controller/java/templates/ClusterInfo-java.zapt +++ b/src/controller/java/templates/ClusterInfo-java.zapt @@ -9,7 +9,7 @@ import java.util.Map; import java.util.List; import java.util.HashMap; import chip.clusterinfo.ClusterInfo; -import chip.clusterinfo.CommandInfo; +import chip.clusterinfo.InteractionInfo; import chip.clusterinfo.CommandParameterInfo; import chip.clusterinfo.DelegatedClusterCallback; import chip.clusterinfo.ClusterCommandCallback; @@ -248,15 +248,34 @@ public class ClusterInfoMapping { {{/chip_client_clusters}} public Map getClusterMap() { + Map clusterMap = initializeClusterMap(); + Map> commandMap = getCommandMap(); + combineCommand(clusterMap, commandMap); + Map> readAttributeMap = getReadAttributeMap(); + combineCommand(clusterMap, readAttributeMap); + return clusterMap; + } + + public Map initializeClusterMap() { Map clusterMap = new HashMap<>(); - getCommandMap(clusterMap); - getReadAttributeMap(clusterMap); + {{#chip_client_clusters}} + ClusterInfo {{asLowerCamelCase name}}ClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.{{asUpperCamelCase name}}Cluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("{{asLowerCamelCase name}}", {{asLowerCamelCase name}}ClusterInfo); + {{/chip_client_clusters}} return clusterMap; } - public Map getCommandMap(Map clusterMap) { + public void combineCommand(Map destination, Map> source) { + {{#chip_client_clusters}} + destination.get("{{asLowerCamelCase name}}").combineCommands(source.get("{{asLowerCamelCase name}}")); + {{/chip_client_clusters}} + } + + public Map> getCommandMap() { + Map> commandMap = new HashMap<>(); {{#chip_client_clusters}} - Map {{asLowerCamelCase name}}ClusterCommandInfoMap = new LinkedHashMap<>(); + Map {{asLowerCamelCase name}}ClusterInteractionInfoMap = new LinkedHashMap<>(); {{#chip_cluster_commands}} Map {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParams = new LinkedHashMap(); {{! TODO: fill out parameter types }} @@ -270,7 +289,7 @@ public class ClusterInfoMapping { {{/if}} // Populate commands {{#if hasSpecificResponse}} - CommandInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandInfo = new CommandInfo( + InteractionInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}InteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.{{asUpperCamelCase ../name}}Cluster) cluster) .{{asLowerCamelCase name}}((ChipClusters.{{asUpperCamelCase ../name}}Cluster.{{asUpperCamelCase responseName}}Callback) callback @@ -284,7 +303,7 @@ public class ClusterInfoMapping { {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParams ); {{else}} - CommandInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandInfo = new CommandInfo( + InteractionInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}InteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.{{asUpperCamelCase ../name}}Cluster) cluster) .{{asLowerCamelCase name}}((DefaultClusterCallback) callback @@ -298,23 +317,21 @@ public class ClusterInfoMapping { {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParams ); {{/if}} - {{asLowerCamelCase ../name}}ClusterCommandInfoMap.put("{{asLowerCamelCase name}}", {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandInfo); + {{asLowerCamelCase ../name}}ClusterInteractionInfoMap.put("{{asLowerCamelCase name}}", {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}InteractionInfo); {{/chip_cluster_commands}} - // Populate cluster - ClusterInfo {{asLowerCamelCase name}}ClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.{{asUpperCamelCase name}}Cluster(ptr, endpointId), {{asLowerCamelCase name}}ClusterCommandInfoMap); - clusterMap.put("{{asLowerCamelCase name}}", {{asLowerCamelCase name}}ClusterInfo); + commandMap.put("{{asLowerCamelCase name}}", {{asLowerCamelCase name}}ClusterInteractionInfoMap); {{/chip_client_clusters}} - return clusterMap; + return commandMap; } - public Map getReadAttributeMap(Map clusterMap) { + public Map> getReadAttributeMap() { + Map> readAttributeMap = new HashMap<>(); {{#chip_client_clusters}} - Map read{{asUpperCamelCase name}}CommandInfo = new LinkedHashMap<>(); + Map read{{asUpperCamelCase name}}InteractionInfo = new LinkedHashMap<>(); // read attribute {{#chip_server_cluster_attributes}} Map read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}CommandParams = new LinkedHashMap(); - CommandInfo read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}AttributeCommandInfo = new CommandInfo( + InteractionInfo read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}AttributeInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.{{asUpperCamelCase ../name}}Cluster) cluster).read{{asUpperCamelCase name}}Attribute( {{#if isList}} @@ -331,12 +348,11 @@ public class ClusterInfoMapping { {{/if}} read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}CommandParams ); - read{{asUpperCamelCase ../name}}CommandInfo.put("read{{asUpperCamelCase name}}Attribute", read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}AttributeCommandInfo); + read{{asUpperCamelCase ../name}}InteractionInfo.put("read{{asUpperCamelCase name}}Attribute", read{{asUpperCamelCase ../name}}{{asUpperCamelCase name}}AttributeInteractionInfo); {{/chip_server_cluster_attributes}} - // combine the read Attribute into the original commands - clusterMap.get("{{asLowerCamelCase name}}").combineCommands(read{{asUpperCamelCase name}}CommandInfo); + readAttributeMap.put("{{asLowerCamelCase name}}", read{{asUpperCamelCase name}}InteractionInfo); {{/chip_client_clusters}} - return clusterMap; + return readAttributeMap; } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 0636e1cc60b37d..1d4f42aed4fd38 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -20,6 +20,7 @@ package chip.devicecontroller; import androidx.annotation.Nullable; +import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -1038,17 +1039,9 @@ public String toString() { output.append(this.type); output.append("\n"); - output.append("byte[] endpoints: ["); - for (int i = 0; i < endpoints.length; i++) { - if (i != endpoints.length - 1) { - output.append(endpoints[i]); - output.append(", "); - } else { - output.append(endpoints[i]); - output.append("]"); - output.append("\n"); - } - } + output.append("byte[] "); + output.append(Arrays.toString(endpoints)); + output.append("\n"); return output.toString(); } @@ -3314,17 +3307,9 @@ public String toString() { output.append(this.offPremiseServicesReachableIPv6); output.append("\n"); - output.append("byte[] hardwareAddress: ["); - for (int i = 0; i < hardwareAddress.length; i++) { - if (i != hardwareAddress.length - 1) { - output.append(hardwareAddress[i]); - output.append(", "); - } else { - output.append(hardwareAddress[i]); - output.append("]"); - output.append("\n"); - } - } + output.append("byte[] "); + output.append(Arrays.toString(hardwareAddress)); + output.append("\n"); output.append("int type: "); output.append(this.type); @@ -3461,17 +3446,9 @@ public String toString() { output.append(this.groupKeyIndex); output.append("\n"); - output.append("byte[] groupKeyRoot: ["); - for (int i = 0; i < groupKeyRoot.length; i++) { - if (i != groupKeyRoot.length - 1) { - output.append(groupKeyRoot[i]); - output.append(", "); - } else { - output.append(groupKeyRoot[i]); - output.append("]"); - output.append("\n"); - } - } + output.append("byte[] "); + output.append(Arrays.toString(groupKeyRoot)); + output.append("\n"); output.append("long groupKeyEpochStartTime: "); output.append(this.groupKeyEpochStartTime); @@ -5261,17 +5238,9 @@ public String toString() { output.append(this.fabricIndex); output.append("\n"); - output.append("byte[] rootPublicKey: ["); - for (int i = 0; i < rootPublicKey.length; i++) { - if (i != rootPublicKey.length - 1) { - output.append(rootPublicKey[i]); - output.append(", "); - } else { - output.append(rootPublicKey[i]); - output.append("]"); - output.append("\n"); - } - } + output.append("byte[] "); + output.append(Arrays.toString(rootPublicKey)); + output.append("\n"); output.append("int vendorId: "); output.append(this.vendorId); @@ -6586,17 +6555,9 @@ public String toString() { output.append(this.fabricIndex); output.append("\n"); - output.append("byte[] operationalCert: ["); - for (int i = 0; i < operationalCert.length; i++) { - if (i != operationalCert.length - 1) { - output.append(operationalCert[i]); - output.append(", "); - } else { - output.append(operationalCert[i]); - output.append("]"); - output.append("\n"); - } - } + output.append("byte[] "); + output.append(Arrays.toString(operationalCert)); + output.append("\n"); return output.toString(); } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 4951539c962c4c..758a98b4219747 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -21,10 +21,10 @@ import chip.clusterinfo.ClusterCommandCallback; import chip.clusterinfo.ClusterInfo; -import chip.clusterinfo.CommandInfo; import chip.clusterinfo.CommandParameterInfo; import chip.clusterinfo.CommandResponseInfo; import chip.clusterinfo.DelegatedClusterCallback; +import chip.clusterinfo.InteractionInfo; import chip.devicecontroller.ChipClusters.DefaultClusterCallback; import java.util.HashMap; import java.util.LinkedHashMap; @@ -3117,14 +3117,387 @@ public void onError(Exception ex) { } public Map getClusterMap() { + Map clusterMap = initializeClusterMap(); + Map> commandMap = getCommandMap(); + combineCommand(clusterMap, commandMap); + Map> readAttributeMap = getReadAttributeMap(); + combineCommand(clusterMap, readAttributeMap); + return clusterMap; + } + + public Map initializeClusterMap() { Map clusterMap = new HashMap<>(); - getCommandMap(clusterMap); - getReadAttributeMap(clusterMap); + ClusterInfo accountLoginClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("accountLogin", accountLoginClusterInfo); + ClusterInfo administratorCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); + ClusterInfo applicationBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("applicationBasic", applicationBasicClusterInfo); + ClusterInfo applicationLauncherClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); + ClusterInfo audioOutputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("audioOutput", audioOutputClusterInfo); + ClusterInfo barrierControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("barrierControl", barrierControlClusterInfo); + ClusterInfo basicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("basic", basicClusterInfo); + ClusterInfo binaryInputBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); + ClusterInfo bindingClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("binding", bindingClusterInfo); + ClusterInfo booleanStateClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("booleanState", booleanStateClusterInfo); + ClusterInfo bridgedActionsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("bridgedActions", bridgedActionsClusterInfo); + ClusterInfo bridgedDeviceBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); + ClusterInfo colorControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("colorControl", colorControlClusterInfo); + ClusterInfo contentLauncherClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("contentLauncher", contentLauncherClusterInfo); + ClusterInfo descriptorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("descriptor", descriptorClusterInfo); + ClusterInfo diagnosticLogsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); + ClusterInfo doorLockClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("doorLock", doorLockClusterInfo); + ClusterInfo electricalMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); + ClusterInfo ethernetNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); + ClusterInfo fixedLabelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("fixedLabel", fixedLabelClusterInfo); + ClusterInfo flowMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); + ClusterInfo generalCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); + ClusterInfo generalDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); + ClusterInfo groupKeyManagementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); + ClusterInfo groupsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("groups", groupsClusterInfo); + ClusterInfo identifyClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("identify", identifyClusterInfo); + ClusterInfo illuminanceMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); + ClusterInfo keypadInputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("keypadInput", keypadInputClusterInfo); + ClusterInfo levelControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("levelControl", levelControlClusterInfo); + ClusterInfo lowPowerClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("lowPower", lowPowerClusterInfo); + ClusterInfo mediaInputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("mediaInput", mediaInputClusterInfo); + ClusterInfo mediaPlaybackClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); + ClusterInfo modeSelectClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("modeSelect", modeSelectClusterInfo); + ClusterInfo networkCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); + ClusterInfo otaSoftwareUpdateProviderClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); + ClusterInfo otaSoftwareUpdateRequestorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); + ClusterInfo occupancySensingClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("occupancySensing", occupancySensingClusterInfo); + ClusterInfo onOffClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("onOff", onOffClusterInfo); + ClusterInfo onOffSwitchConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); + ClusterInfo operationalCredentialsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); + ClusterInfo powerSourceClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("powerSource", powerSourceClusterInfo); + ClusterInfo pressureMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); + ClusterInfo pumpConfigurationAndControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); + ClusterInfo relativeHumidityMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); + ClusterInfo scenesClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("scenes", scenesClusterInfo); + ClusterInfo softwareDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); + ClusterInfo switchClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("switch", switchClusterInfo); + ClusterInfo tvChannelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TvChannelCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("tvChannel", tvChannelClusterInfo); + ClusterInfo targetNavigatorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("targetNavigator", targetNavigatorClusterInfo); + ClusterInfo temperatureMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); + ClusterInfo testClusterClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("testCluster", testClusterClusterInfo); + ClusterInfo thermostatClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("thermostat", thermostatClusterInfo); + ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put( + "thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); + ClusterInfo threadNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); + ClusterInfo wakeOnLanClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); + ClusterInfo wiFiNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); + ClusterInfo windowCoveringClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("windowCovering", windowCoveringClusterInfo); return clusterMap; } - public Map getCommandMap(Map clusterMap) { - Map accountLoginClusterCommandInfoMap = new LinkedHashMap<>(); + public void combineCommand( + Map destination, Map> source) { + destination.get("accountLogin").combineCommands(source.get("accountLogin")); + destination + .get("administratorCommissioning") + .combineCommands(source.get("administratorCommissioning")); + destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); + destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); + destination.get("audioOutput").combineCommands(source.get("audioOutput")); + destination.get("barrierControl").combineCommands(source.get("barrierControl")); + destination.get("basic").combineCommands(source.get("basic")); + destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); + destination.get("binding").combineCommands(source.get("binding")); + destination.get("booleanState").combineCommands(source.get("booleanState")); + destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); + destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); + destination.get("colorControl").combineCommands(source.get("colorControl")); + destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); + destination.get("descriptor").combineCommands(source.get("descriptor")); + destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); + destination.get("doorLock").combineCommands(source.get("doorLock")); + destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); + destination + .get("ethernetNetworkDiagnostics") + .combineCommands(source.get("ethernetNetworkDiagnostics")); + destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); + destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); + destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); + destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); + destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); + destination.get("groups").combineCommands(source.get("groups")); + destination.get("identify").combineCommands(source.get("identify")); + destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); + destination.get("keypadInput").combineCommands(source.get("keypadInput")); + destination.get("levelControl").combineCommands(source.get("levelControl")); + destination.get("lowPower").combineCommands(source.get("lowPower")); + destination.get("mediaInput").combineCommands(source.get("mediaInput")); + destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); + destination.get("modeSelect").combineCommands(source.get("modeSelect")); + destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); + destination + .get("otaSoftwareUpdateProvider") + .combineCommands(source.get("otaSoftwareUpdateProvider")); + destination + .get("otaSoftwareUpdateRequestor") + .combineCommands(source.get("otaSoftwareUpdateRequestor")); + destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); + destination.get("onOff").combineCommands(source.get("onOff")); + destination + .get("onOffSwitchConfiguration") + .combineCommands(source.get("onOffSwitchConfiguration")); + destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); + destination.get("powerSource").combineCommands(source.get("powerSource")); + destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); + destination + .get("pumpConfigurationAndControl") + .combineCommands(source.get("pumpConfigurationAndControl")); + destination + .get("relativeHumidityMeasurement") + .combineCommands(source.get("relativeHumidityMeasurement")); + destination.get("scenes").combineCommands(source.get("scenes")); + destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); + destination.get("switch").combineCommands(source.get("switch")); + destination.get("tvChannel").combineCommands(source.get("tvChannel")); + destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); + destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); + destination.get("testCluster").combineCommands(source.get("testCluster")); + destination.get("thermostat").combineCommands(source.get("thermostat")); + destination + .get("thermostatUserInterfaceConfiguration") + .combineCommands(source.get("thermostatUserInterfaceConfiguration")); + destination + .get("threadNetworkDiagnostics") + .combineCommands(source.get("threadNetworkDiagnostics")); + destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); + destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); + destination.get("windowCovering").combineCommands(source.get("windowCovering")); + } + + public Map> getCommandMap() { + Map> commandMap = new HashMap<>(); + Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); Map accountLogingetSetupPINCommandParams = new LinkedHashMap(); CommandParameterInfo accountLogingetSetupPINtempAccountIdentifierCommandParameterInfo = @@ -3133,8 +3506,8 @@ public Map getCommandMap(Map clusterMa "tempAccountIdentifier", accountLogingetSetupPINtempAccountIdentifierCommandParameterInfo); // Populate commands - CommandInfo accountLogingetSetupPINCommandInfo = - new CommandInfo( + InteractionInfo accountLogingetSetupPINInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AccountLoginCluster) cluster) .getSetupPIN( @@ -3143,7 +3516,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetSetupPINResponseCallback(), accountLogingetSetupPINCommandParams); - accountLoginClusterCommandInfoMap.put("getSetupPIN", accountLogingetSetupPINCommandInfo); + accountLoginClusterInteractionInfoMap.put( + "getSetupPIN", accountLogingetSetupPINInteractionInfo); Map accountLoginloginCommandParams = new LinkedHashMap(); CommandParameterInfo accountLoginlogintempAccountIdentifierCommandParameterInfo = @@ -3156,8 +3530,8 @@ public Map getCommandMap(Map clusterMa accountLoginloginCommandParams.put("setupPIN", accountLoginloginsetupPINCommandParameterInfo); // Populate commands - CommandInfo accountLoginloginCommandInfo = - new CommandInfo( + InteractionInfo accountLoginloginInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AccountLoginCluster) cluster) .login( @@ -3167,14 +3541,9 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), accountLoginloginCommandParams); - accountLoginClusterCommandInfoMap.put("login", accountLoginloginCommandInfo); - // Populate cluster - ClusterInfo accountLoginClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), - accountLoginClusterCommandInfoMap); - clusterMap.put("accountLogin", accountLoginClusterInfo); - Map administratorCommissioningClusterCommandInfoMap = + accountLoginClusterInteractionInfoMap.put("login", accountLoginloginInteractionInfo); + commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); + Map administratorCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); Map administratorCommissioningopenBasicCommissioningWindowCommandParams = @@ -3187,8 +3556,8 @@ public Map getCommandMap(Map clusterMa administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); // Populate commands - CommandInfo administratorCommissioningopenBasicCommissioningWindowCommandInfo = - new CommandInfo( + InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) .openBasicCommissioningWindow( @@ -3197,9 +3566,9 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), administratorCommissioningopenBasicCommissioningWindowCommandParams); - administratorCommissioningClusterCommandInfoMap.put( + administratorCommissioningClusterInteractionInfoMap.put( "openBasicCommissioningWindow", - administratorCommissioningopenBasicCommissioningWindowCommandInfo); + administratorCommissioningopenBasicCommissioningWindowInteractionInfo); Map administratorCommissioningopenCommissioningWindowCommandParams = new LinkedHashMap(); @@ -3244,8 +3613,8 @@ public Map getCommandMap(Map clusterMa administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); // Populate commands - CommandInfo administratorCommissioningopenCommissioningWindowCommandInfo = - new CommandInfo( + InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) .openCommissioningWindow( @@ -3259,29 +3628,25 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), administratorCommissioningopenCommissioningWindowCommandParams); - administratorCommissioningClusterCommandInfoMap.put( - "openCommissioningWindow", administratorCommissioningopenCommissioningWindowCommandInfo); + administratorCommissioningClusterInteractionInfoMap.put( + "openCommissioningWindow", + administratorCommissioningopenCommissioningWindowInteractionInfo); Map administratorCommissioningrevokeCommissioningCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo administratorCommissioningrevokeCommissioningCommandInfo = - new CommandInfo( + InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) .revokeCommissioning((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), administratorCommissioningrevokeCommissioningCommandParams); - administratorCommissioningClusterCommandInfoMap.put( - "revokeCommissioning", administratorCommissioningrevokeCommissioningCommandInfo); - // Populate cluster - ClusterInfo administratorCommissioningClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), - administratorCommissioningClusterCommandInfoMap); - clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); - Map applicationBasicClusterCommandInfoMap = new LinkedHashMap<>(); + administratorCommissioningClusterInteractionInfoMap.put( + "revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); + commandMap.put( + "administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); + Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); Map applicationBasicchangeStatusCommandParams = new LinkedHashMap(); CommandParameterInfo applicationBasicchangeStatusstatusCommandParameterInfo = @@ -3290,8 +3655,8 @@ public Map getCommandMap(Map clusterMa "status", applicationBasicchangeStatusstatusCommandParameterInfo); // Populate commands - CommandInfo applicationBasicchangeStatusCommandInfo = - new CommandInfo( + InteractionInfo applicationBasicchangeStatusInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) .changeStatus( @@ -3299,15 +3664,11 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), applicationBasicchangeStatusCommandParams); - applicationBasicClusterCommandInfoMap.put( - "changeStatus", applicationBasicchangeStatusCommandInfo); - // Populate cluster - ClusterInfo applicationBasicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), - applicationBasicClusterCommandInfoMap); - clusterMap.put("applicationBasic", applicationBasicClusterInfo); - Map applicationLauncherClusterCommandInfoMap = new LinkedHashMap<>(); + applicationBasicClusterInteractionInfoMap.put( + "changeStatus", applicationBasicchangeStatusInteractionInfo); + commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); + Map applicationLauncherClusterInteractionInfoMap = + new LinkedHashMap<>(); Map applicationLauncherlaunchAppCommandParams = new LinkedHashMap(); CommandParameterInfo applicationLauncherlaunchAppdataCommandParameterInfo = @@ -3326,8 +3687,8 @@ public Map getCommandMap(Map clusterMa "applicationId", applicationLauncherlaunchAppapplicationIdCommandParameterInfo); // Populate commands - CommandInfo applicationLauncherlaunchAppCommandInfo = - new CommandInfo( + InteractionInfo applicationLauncherlaunchAppInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationLauncherCluster) cluster) .launchApp( @@ -3338,15 +3699,10 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedLaunchAppResponseCallback(), applicationLauncherlaunchAppCommandParams); - applicationLauncherClusterCommandInfoMap.put( - "launchApp", applicationLauncherlaunchAppCommandInfo); - // Populate cluster - ClusterInfo applicationLauncherClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), - applicationLauncherClusterCommandInfoMap); - clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); - Map audioOutputClusterCommandInfoMap = new LinkedHashMap<>(); + applicationLauncherClusterInteractionInfoMap.put( + "launchApp", applicationLauncherlaunchAppInteractionInfo); + commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); + Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); Map audioOutputrenameOutputCommandParams = new LinkedHashMap(); CommandParameterInfo audioOutputrenameOutputindexCommandParameterInfo = @@ -3360,8 +3716,8 @@ public Map getCommandMap(Map clusterMa "name", audioOutputrenameOutputnameCommandParameterInfo); // Populate commands - CommandInfo audioOutputrenameOutputCommandInfo = - new CommandInfo( + InteractionInfo audioOutputrenameOutputInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) .renameOutput( @@ -3371,7 +3727,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), audioOutputrenameOutputCommandParams); - audioOutputClusterCommandInfoMap.put("renameOutput", audioOutputrenameOutputCommandInfo); + audioOutputClusterInteractionInfoMap.put( + "renameOutput", audioOutputrenameOutputInteractionInfo); Map audioOutputselectOutputCommandParams = new LinkedHashMap(); CommandParameterInfo audioOutputselectOutputindexCommandParameterInfo = @@ -3380,8 +3737,8 @@ public Map getCommandMap(Map clusterMa "index", audioOutputselectOutputindexCommandParameterInfo); // Populate commands - CommandInfo audioOutputselectOutputCommandInfo = - new CommandInfo( + InteractionInfo audioOutputselectOutputInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) .selectOutput( @@ -3389,14 +3746,10 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), audioOutputselectOutputCommandParams); - audioOutputClusterCommandInfoMap.put("selectOutput", audioOutputselectOutputCommandInfo); - // Populate cluster - ClusterInfo audioOutputClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), - audioOutputClusterCommandInfoMap); - clusterMap.put("audioOutput", audioOutputClusterInfo); - Map barrierControlClusterCommandInfoMap = new LinkedHashMap<>(); + audioOutputClusterInteractionInfoMap.put( + "selectOutput", audioOutputselectOutputInteractionInfo); + commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); + Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); Map barrierControlbarrierControlGoToPercentCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = @@ -3405,8 +3758,8 @@ public Map getCommandMap(Map clusterMa "percentOpen", barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); // Populate commands - CommandInfo barrierControlbarrierControlGoToPercentCommandInfo = - new CommandInfo( + InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .barrierControlGoToPercent( @@ -3415,54 +3768,39 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), barrierControlbarrierControlGoToPercentCommandParams); - barrierControlClusterCommandInfoMap.put( - "barrierControlGoToPercent", barrierControlbarrierControlGoToPercentCommandInfo); + barrierControlClusterInteractionInfoMap.put( + "barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); Map barrierControlbarrierControlStopCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo barrierControlbarrierControlStopCommandInfo = - new CommandInfo( + InteractionInfo barrierControlbarrierControlStopInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .barrierControlStop((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), barrierControlbarrierControlStopCommandParams); - barrierControlClusterCommandInfoMap.put( - "barrierControlStop", barrierControlbarrierControlStopCommandInfo); - // Populate cluster - ClusterInfo barrierControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), - barrierControlClusterCommandInfoMap); - clusterMap.put("barrierControl", barrierControlClusterInfo); - Map basicClusterCommandInfoMap = new LinkedHashMap<>(); + barrierControlClusterInteractionInfoMap.put( + "barrierControlStop", barrierControlbarrierControlStopInteractionInfo); + commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); + Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); Map basicmfgSpecificPingCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo basicmfgSpecificPingCommandInfo = - new CommandInfo( + InteractionInfo basicmfgSpecificPingInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .mfgSpecificPing((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), basicmfgSpecificPingCommandParams); - basicClusterCommandInfoMap.put("mfgSpecificPing", basicmfgSpecificPingCommandInfo); - // Populate cluster - ClusterInfo basicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), - basicClusterCommandInfoMap); - clusterMap.put("basic", basicClusterInfo); - Map binaryInputBasicClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo binaryInputBasicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), - binaryInputBasicClusterCommandInfoMap); - clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); - Map bindingClusterCommandInfoMap = new LinkedHashMap<>(); + basicClusterInteractionInfoMap.put("mfgSpecificPing", basicmfgSpecificPingInteractionInfo); + commandMap.put("basic", basicClusterInteractionInfoMap); + Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); + Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); Map bindingbindCommandParams = new LinkedHashMap(); CommandParameterInfo bindingbindnodeIdCommandParameterInfo = @@ -3482,8 +3820,8 @@ public Map getCommandMap(Map clusterMa bindingbindCommandParams.put("clusterId", bindingbindclusterIdCommandParameterInfo); // Populate commands - CommandInfo bindingbindCommandInfo = - new CommandInfo( + InteractionInfo bindingbindInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BindingCluster) cluster) .bind( @@ -3495,7 +3833,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bindingbindCommandParams); - bindingClusterCommandInfoMap.put("bind", bindingbindCommandInfo); + bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); Map bindingunbindCommandParams = new LinkedHashMap(); CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = @@ -3515,8 +3853,8 @@ public Map getCommandMap(Map clusterMa bindingunbindCommandParams.put("clusterId", bindingunbindclusterIdCommandParameterInfo); // Populate commands - CommandInfo bindingunbindCommandInfo = - new CommandInfo( + InteractionInfo bindingunbindInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BindingCluster) cluster) .unbind( @@ -3528,21 +3866,11 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bindingunbindCommandParams); - bindingClusterCommandInfoMap.put("unbind", bindingunbindCommandInfo); - // Populate cluster - ClusterInfo bindingClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), - bindingClusterCommandInfoMap); - clusterMap.put("binding", bindingClusterInfo); - Map booleanStateClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo booleanStateClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), - booleanStateClusterCommandInfoMap); - clusterMap.put("booleanState", booleanStateClusterInfo); - Map bridgedActionsClusterCommandInfoMap = new LinkedHashMap<>(); + bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); + commandMap.put("binding", bindingClusterInteractionInfoMap); + Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); + Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); Map bridgedActionsdisableActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = @@ -3556,8 +3884,8 @@ public Map getCommandMap(Map clusterMa "invokeID", bridgedActionsdisableActioninvokeIDCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsdisableActionCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsdisableActionInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .disableAction( @@ -3567,8 +3895,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsdisableActionCommandParams); - bridgedActionsClusterCommandInfoMap.put( - "disableAction", bridgedActionsdisableActionCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "disableAction", bridgedActionsdisableActionInteractionInfo); Map bridgedActionsdisableActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = @@ -3587,8 +3915,8 @@ public Map getCommandMap(Map clusterMa "duration", bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsdisableActionWithDurationCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .disableActionWithDuration( @@ -3599,8 +3927,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsdisableActionWithDurationCommandParams); - bridgedActionsClusterCommandInfoMap.put( - "disableActionWithDuration", bridgedActionsdisableActionWithDurationCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); Map bridgedActionsenableActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = @@ -3614,8 +3942,8 @@ public Map getCommandMap(Map clusterMa "invokeID", bridgedActionsenableActioninvokeIDCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsenableActionCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsenableActionInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .enableAction( @@ -3625,7 +3953,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsenableActionCommandParams); - bridgedActionsClusterCommandInfoMap.put("enableAction", bridgedActionsenableActionCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "enableAction", bridgedActionsenableActionInteractionInfo); Map bridgedActionsenableActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = @@ -3644,8 +3973,8 @@ public Map getCommandMap(Map clusterMa "duration", bridgedActionsenableActionWithDurationdurationCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsenableActionWithDurationCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .enableActionWithDuration( @@ -3656,8 +3985,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsenableActionWithDurationCommandParams); - bridgedActionsClusterCommandInfoMap.put( - "enableActionWithDuration", bridgedActionsenableActionWithDurationCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); Map bridgedActionsinstantActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = @@ -3671,8 +4000,8 @@ public Map getCommandMap(Map clusterMa "invokeID", bridgedActionsinstantActioninvokeIDCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsinstantActionCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsinstantActionInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .instantAction( @@ -3682,8 +4011,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsinstantActionCommandParams); - bridgedActionsClusterCommandInfoMap.put( - "instantAction", bridgedActionsinstantActionCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "instantAction", bridgedActionsinstantActionInteractionInfo); Map bridgedActionsinstantActionWithTransitionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = @@ -3704,8 +4033,8 @@ public Map getCommandMap(Map clusterMa bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsinstantActionWithTransitionCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .instantActionWithTransition( @@ -3716,8 +4045,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsinstantActionWithTransitionCommandParams); - bridgedActionsClusterCommandInfoMap.put( - "instantActionWithTransition", bridgedActionsinstantActionWithTransitionCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); Map bridgedActionspauseActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = @@ -3731,8 +4060,8 @@ public Map getCommandMap(Map clusterMa "invokeID", bridgedActionspauseActioninvokeIDCommandParameterInfo); // Populate commands - CommandInfo bridgedActionspauseActionCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionspauseActionInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .pauseAction( @@ -3742,7 +4071,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionspauseActionCommandParams); - bridgedActionsClusterCommandInfoMap.put("pauseAction", bridgedActionspauseActionCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "pauseAction", bridgedActionspauseActionInteractionInfo); Map bridgedActionspauseActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = @@ -3761,8 +4091,8 @@ public Map getCommandMap(Map clusterMa "duration", bridgedActionspauseActionWithDurationdurationCommandParameterInfo); // Populate commands - CommandInfo bridgedActionspauseActionWithDurationCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .pauseActionWithDuration( @@ -3773,8 +4103,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionspauseActionWithDurationCommandParams); - bridgedActionsClusterCommandInfoMap.put( - "pauseActionWithDuration", bridgedActionspauseActionWithDurationCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); Map bridgedActionsresumeActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = @@ -3788,8 +4118,8 @@ public Map getCommandMap(Map clusterMa "invokeID", bridgedActionsresumeActioninvokeIDCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsresumeActionCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsresumeActionInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .resumeAction( @@ -3799,7 +4129,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsresumeActionCommandParams); - bridgedActionsClusterCommandInfoMap.put("resumeAction", bridgedActionsresumeActionCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "resumeAction", bridgedActionsresumeActionInteractionInfo); Map bridgedActionsstartActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = @@ -3813,8 +4144,8 @@ public Map getCommandMap(Map clusterMa "invokeID", bridgedActionsstartActioninvokeIDCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsstartActionCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsstartActionInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .startAction( @@ -3824,7 +4155,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsstartActionCommandParams); - bridgedActionsClusterCommandInfoMap.put("startAction", bridgedActionsstartActionCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "startAction", bridgedActionsstartActionInteractionInfo); Map bridgedActionsstartActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = @@ -3843,8 +4175,8 @@ public Map getCommandMap(Map clusterMa "duration", bridgedActionsstartActionWithDurationdurationCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsstartActionWithDurationCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .startActionWithDuration( @@ -3855,8 +4187,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsstartActionWithDurationCommandParams); - bridgedActionsClusterCommandInfoMap.put( - "startActionWithDuration", bridgedActionsstartActionWithDurationCommandInfo); + bridgedActionsClusterInteractionInfoMap.put( + "startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); Map bridgedActionsstopActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = @@ -3870,8 +4202,8 @@ public Map getCommandMap(Map clusterMa "invokeID", bridgedActionsstopActioninvokeIDCommandParameterInfo); // Populate commands - CommandInfo bridgedActionsstopActionCommandInfo = - new CommandInfo( + InteractionInfo bridgedActionsstopActionInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .stopAction( @@ -3881,21 +4213,13 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), bridgedActionsstopActionCommandParams); - bridgedActionsClusterCommandInfoMap.put("stopAction", bridgedActionsstopActionCommandInfo); - // Populate cluster - ClusterInfo bridgedActionsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), - bridgedActionsClusterCommandInfoMap); - clusterMap.put("bridgedActions", bridgedActionsClusterInfo); - Map bridgedDeviceBasicClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo bridgedDeviceBasicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), - bridgedDeviceBasicClusterCommandInfoMap); - clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); - Map colorControlClusterCommandInfoMap = new LinkedHashMap<>(); + bridgedActionsClusterInteractionInfoMap.put( + "stopAction", bridgedActionsstopActionInteractionInfo); + commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); + Map bridgedDeviceBasicClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); + Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); Map colorControlcolorLoopSetCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = @@ -3934,8 +4258,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlcolorLoopSetCommandInfo = - new CommandInfo( + InteractionInfo colorControlcolorLoopSetInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .colorLoopSet( @@ -3950,7 +4274,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlcolorLoopSetCommandParams); - colorControlClusterCommandInfoMap.put("colorLoopSet", colorControlcolorLoopSetCommandInfo); + colorControlClusterInteractionInfoMap.put( + "colorLoopSet", colorControlcolorLoopSetInteractionInfo); Map colorControlenhancedMoveHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = @@ -3974,8 +4299,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlenhancedMoveHueCommandInfo = - new CommandInfo( + InteractionInfo colorControlenhancedMoveHueInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .enhancedMoveHue( @@ -3987,8 +4312,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlenhancedMoveHueCommandParams); - colorControlClusterCommandInfoMap.put( - "enhancedMoveHue", colorControlenhancedMoveHueCommandInfo); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); Map colorControlenhancedMoveToHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = @@ -4017,8 +4342,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlenhancedMoveToHueCommandInfo = - new CommandInfo( + InteractionInfo colorControlenhancedMoveToHueInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .enhancedMoveToHue( @@ -4031,8 +4356,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlenhancedMoveToHueCommandParams); - colorControlClusterCommandInfoMap.put( - "enhancedMoveToHue", colorControlenhancedMoveToHueCommandInfo); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); Map colorControlenhancedMoveToHueAndSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = @@ -4065,8 +4390,8 @@ public Map getCommandMap(Map clusterMa colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlenhancedMoveToHueAndSaturationCommandInfo = - new CommandInfo( + InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .enhancedMoveToHueAndSaturation( @@ -4079,8 +4404,9 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlenhancedMoveToHueAndSaturationCommandParams); - colorControlClusterCommandInfoMap.put( - "enhancedMoveToHueAndSaturation", colorControlenhancedMoveToHueAndSaturationCommandInfo); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveToHueAndSaturation", + colorControlenhancedMoveToHueAndSaturationInteractionInfo); Map colorControlenhancedStepHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = @@ -4109,8 +4435,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlenhancedStepHueCommandInfo = - new CommandInfo( + InteractionInfo colorControlenhancedStepHueInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .enhancedStepHue( @@ -4123,8 +4449,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlenhancedStepHueCommandParams); - colorControlClusterCommandInfoMap.put( - "enhancedStepHue", colorControlenhancedStepHueCommandInfo); + colorControlClusterInteractionInfoMap.put( + "enhancedStepHue", colorControlenhancedStepHueInteractionInfo); Map colorControlmoveColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = @@ -4146,8 +4472,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlmoveColoroptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlmoveColorCommandInfo = - new CommandInfo( + InteractionInfo colorControlmoveColorInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .moveColor( @@ -4159,7 +4485,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlmoveColorCommandParams); - colorControlClusterCommandInfoMap.put("moveColor", colorControlmoveColorCommandInfo); + colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); Map colorControlmoveColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = @@ -4197,8 +4523,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlmoveColorTemperatureCommandInfo = - new CommandInfo( + InteractionInfo colorControlmoveColorTemperatureInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .moveColorTemperature( @@ -4212,8 +4538,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlmoveColorTemperatureCommandParams); - colorControlClusterCommandInfoMap.put( - "moveColorTemperature", colorControlmoveColorTemperatureCommandInfo); + colorControlClusterInteractionInfoMap.put( + "moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); Map colorControlmoveHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = @@ -4236,8 +4562,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlmoveHueoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlmoveHueCommandInfo = - new CommandInfo( + InteractionInfo colorControlmoveHueInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .moveHue( @@ -4249,7 +4575,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlmoveHueCommandParams); - colorControlClusterCommandInfoMap.put("moveHue", colorControlmoveHueCommandInfo); + colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); Map colorControlmoveSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = @@ -4273,8 +4599,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlmoveSaturationoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlmoveSaturationCommandInfo = - new CommandInfo( + InteractionInfo colorControlmoveSaturationInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .moveSaturation( @@ -4286,7 +4612,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlmoveSaturationCommandParams); - colorControlClusterCommandInfoMap.put("moveSaturation", colorControlmoveSaturationCommandInfo); + colorControlClusterInteractionInfoMap.put( + "moveSaturation", colorControlmoveSaturationInteractionInfo); Map colorControlmoveToColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = @@ -4315,8 +4642,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlmoveToColoroptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlmoveToColorCommandInfo = - new CommandInfo( + InteractionInfo colorControlmoveToColorInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .moveToColor( @@ -4329,7 +4656,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlmoveToColorCommandParams); - colorControlClusterCommandInfoMap.put("moveToColor", colorControlmoveToColorCommandInfo); + colorControlClusterInteractionInfoMap.put( + "moveToColor", colorControlmoveToColorInteractionInfo); Map colorControlmoveToColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = @@ -4353,8 +4681,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlmoveToColorTemperatureCommandInfo = - new CommandInfo( + InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .moveToColorTemperature( @@ -4366,8 +4694,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlmoveToColorTemperatureCommandParams); - colorControlClusterCommandInfoMap.put( - "moveToColorTemperature", colorControlmoveToColorTemperatureCommandInfo); + colorControlClusterInteractionInfoMap.put( + "moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); Map colorControlmoveToHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = @@ -4395,8 +4723,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlmoveToHueoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlmoveToHueCommandInfo = - new CommandInfo( + InteractionInfo colorControlmoveToHueInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .moveToHue( @@ -4409,7 +4737,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlmoveToHueCommandParams); - colorControlClusterCommandInfoMap.put("moveToHue", colorControlmoveToHueCommandInfo); + colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); Map colorControlmoveToHueAndSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = @@ -4438,8 +4766,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlmoveToHueAndSaturationCommandInfo = - new CommandInfo( + InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .moveToHueAndSaturation( @@ -4452,8 +4780,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlmoveToHueAndSaturationCommandParams); - colorControlClusterCommandInfoMap.put( - "moveToHueAndSaturation", colorControlmoveToHueAndSaturationCommandInfo); + colorControlClusterInteractionInfoMap.put( + "moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); Map colorControlmoveToSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = @@ -4477,8 +4805,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlmoveToSaturationCommandInfo = - new CommandInfo( + InteractionInfo colorControlmoveToSaturationInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .moveToSaturation( @@ -4490,8 +4818,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlmoveToSaturationCommandParams); - colorControlClusterCommandInfoMap.put( - "moveToSaturation", colorControlmoveToSaturationCommandInfo); + colorControlClusterInteractionInfoMap.put( + "moveToSaturation", colorControlmoveToSaturationInteractionInfo); Map colorControlstepColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = @@ -4518,8 +4846,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlstepColoroptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlstepColorCommandInfo = - new CommandInfo( + InteractionInfo colorControlstepColorInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .stepColor( @@ -4532,7 +4860,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlstepColorCommandParams); - colorControlClusterCommandInfoMap.put("stepColor", colorControlstepColorCommandInfo); + colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); Map colorControlstepColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = @@ -4575,8 +4903,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlstepColorTemperatureCommandInfo = - new CommandInfo( + InteractionInfo colorControlstepColorTemperatureInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .stepColorTemperature( @@ -4591,8 +4919,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlstepColorTemperatureCommandParams); - colorControlClusterCommandInfoMap.put( - "stepColorTemperature", colorControlstepColorTemperatureCommandInfo); + colorControlClusterInteractionInfoMap.put( + "stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); Map colorControlstepHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = @@ -4621,8 +4949,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlstepHueoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlstepHueCommandInfo = - new CommandInfo( + InteractionInfo colorControlstepHueInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .stepHue( @@ -4635,7 +4963,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlstepHueCommandParams); - colorControlClusterCommandInfoMap.put("stepHue", colorControlstepHueCommandInfo); + colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); Map colorControlstepSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = @@ -4664,8 +4992,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlstepSaturationoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlstepSaturationCommandInfo = - new CommandInfo( + InteractionInfo colorControlstepSaturationInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .stepSaturation( @@ -4678,7 +5006,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlstepSaturationCommandParams); - colorControlClusterCommandInfoMap.put("stepSaturation", colorControlstepSaturationCommandInfo); + colorControlClusterInteractionInfoMap.put( + "stepSaturation", colorControlstepSaturationInteractionInfo); Map colorControlstopMoveStepCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = @@ -4692,8 +5021,8 @@ public Map getCommandMap(Map clusterMa "optionsOverride", colorControlstopMoveStepoptionsOverrideCommandParameterInfo); // Populate commands - CommandInfo colorControlstopMoveStepCommandInfo = - new CommandInfo( + InteractionInfo colorControlstopMoveStepInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .stopMoveStep( @@ -4703,14 +5032,10 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), colorControlstopMoveStepCommandParams); - colorControlClusterCommandInfoMap.put("stopMoveStep", colorControlstopMoveStepCommandInfo); - // Populate cluster - ClusterInfo colorControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), - colorControlClusterCommandInfoMap); - clusterMap.put("colorControl", colorControlClusterInfo); - Map contentLauncherClusterCommandInfoMap = new LinkedHashMap<>(); + colorControlClusterInteractionInfoMap.put( + "stopMoveStep", colorControlstopMoveStepInteractionInfo); + commandMap.put("colorControl", colorControlClusterInteractionInfoMap); + Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); Map contentLauncherlaunchContentCommandParams = new LinkedHashMap(); CommandParameterInfo contentLauncherlaunchContentautoPlayCommandParameterInfo = @@ -4724,8 +5049,8 @@ public Map getCommandMap(Map clusterMa "data", contentLauncherlaunchContentdataCommandParameterInfo); // Populate commands - CommandInfo contentLauncherlaunchContentCommandInfo = - new CommandInfo( + InteractionInfo contentLauncherlaunchContentInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) .launchContent( @@ -4735,8 +5060,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedLaunchContentResponseCallback(), contentLauncherlaunchContentCommandParams); - contentLauncherClusterCommandInfoMap.put( - "launchContent", contentLauncherlaunchContentCommandInfo); + contentLauncherClusterInteractionInfoMap.put( + "launchContent", contentLauncherlaunchContentInteractionInfo); Map contentLauncherlaunchURLCommandParams = new LinkedHashMap(); CommandParameterInfo contentLauncherlaunchURLcontentURLCommandParameterInfo = @@ -4750,8 +5075,8 @@ public Map getCommandMap(Map clusterMa "displayString", contentLauncherlaunchURLdisplayStringCommandParameterInfo); // Populate commands - CommandInfo contentLauncherlaunchURLCommandInfo = - new CommandInfo( + InteractionInfo contentLauncherlaunchURLInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) .launchURL( @@ -4761,21 +5086,12 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedLaunchURLResponseCallback(), contentLauncherlaunchURLCommandParams); - contentLauncherClusterCommandInfoMap.put("launchURL", contentLauncherlaunchURLCommandInfo); - // Populate cluster - ClusterInfo contentLauncherClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), - contentLauncherClusterCommandInfoMap); - clusterMap.put("contentLauncher", contentLauncherClusterInfo); - Map descriptorClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo descriptorClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), - descriptorClusterCommandInfoMap); - clusterMap.put("descriptor", descriptorClusterInfo); - Map diagnosticLogsClusterCommandInfoMap = new LinkedHashMap<>(); + contentLauncherClusterInteractionInfoMap.put( + "launchURL", contentLauncherlaunchURLInteractionInfo); + commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); + Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("descriptor", descriptorClusterInteractionInfoMap); + Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); Map diagnosticLogsretrieveLogsRequestCommandParams = new LinkedHashMap(); CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = @@ -4797,8 +5113,8 @@ public Map getCommandMap(Map clusterMa diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); // Populate commands - CommandInfo diagnosticLogsretrieveLogsRequestCommandInfo = - new CommandInfo( + InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DiagnosticLogsCluster) cluster) .retrieveLogsRequest( @@ -4809,20 +5125,15 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedRetrieveLogsResponseCallback(), diagnosticLogsretrieveLogsRequestCommandParams); - diagnosticLogsClusterCommandInfoMap.put( - "retrieveLogsRequest", diagnosticLogsretrieveLogsRequestCommandInfo); - // Populate cluster - ClusterInfo diagnosticLogsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), - diagnosticLogsClusterCommandInfoMap); - clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); - Map doorLockClusterCommandInfoMap = new LinkedHashMap<>(); + diagnosticLogsClusterInteractionInfoMap.put( + "retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); + commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); + Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); Map doorLockclearAllPinsCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo doorLockclearAllPinsCommandInfo = - new CommandInfo( + InteractionInfo doorLockclearAllPinsInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .clearAllPins( @@ -4830,12 +5141,12 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedClearAllPinsResponseCallback(), doorLockclearAllPinsCommandParams); - doorLockClusterCommandInfoMap.put("clearAllPins", doorLockclearAllPinsCommandInfo); + doorLockClusterInteractionInfoMap.put("clearAllPins", doorLockclearAllPinsInteractionInfo); Map doorLockclearAllRfidsCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo doorLockclearAllRfidsCommandInfo = - new CommandInfo( + InteractionInfo doorLockclearAllRfidsInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .clearAllRfids( @@ -4843,7 +5154,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedClearAllRfidsResponseCallback(), doorLockclearAllRfidsCommandParams); - doorLockClusterCommandInfoMap.put("clearAllRfids", doorLockclearAllRfidsCommandInfo); + doorLockClusterInteractionInfoMap.put("clearAllRfids", doorLockclearAllRfidsInteractionInfo); Map doorLockclearHolidayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearHolidaySchedulescheduleIdCommandParameterInfo = @@ -4852,8 +5163,8 @@ public Map getCommandMap(Map clusterMa "scheduleId", doorLockclearHolidaySchedulescheduleIdCommandParameterInfo); // Populate commands - CommandInfo doorLockclearHolidayScheduleCommandInfo = - new CommandInfo( + InteractionInfo doorLockclearHolidayScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .clearHolidaySchedule( @@ -4862,8 +5173,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedClearHolidayScheduleResponseCallback(), doorLockclearHolidayScheduleCommandParams); - doorLockClusterCommandInfoMap.put( - "clearHolidaySchedule", doorLockclearHolidayScheduleCommandInfo); + doorLockClusterInteractionInfoMap.put( + "clearHolidaySchedule", doorLockclearHolidayScheduleInteractionInfo); Map doorLockclearPinCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearPinuserIdCommandParameterInfo = @@ -4871,8 +5182,8 @@ public Map getCommandMap(Map clusterMa doorLockclearPinCommandParams.put("userId", doorLockclearPinuserIdCommandParameterInfo); // Populate commands - CommandInfo doorLockclearPinCommandInfo = - new CommandInfo( + InteractionInfo doorLockclearPinInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .clearPin( @@ -4881,7 +5192,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedClearPinResponseCallback(), doorLockclearPinCommandParams); - doorLockClusterCommandInfoMap.put("clearPin", doorLockclearPinCommandInfo); + doorLockClusterInteractionInfoMap.put("clearPin", doorLockclearPinInteractionInfo); Map doorLockclearRfidCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearRfiduserIdCommandParameterInfo = @@ -4889,8 +5200,8 @@ public Map getCommandMap(Map clusterMa doorLockclearRfidCommandParams.put("userId", doorLockclearRfiduserIdCommandParameterInfo); // Populate commands - CommandInfo doorLockclearRfidCommandInfo = - new CommandInfo( + InteractionInfo doorLockclearRfidInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .clearRfid( @@ -4899,7 +5210,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedClearRfidResponseCallback(), doorLockclearRfidCommandParams); - doorLockClusterCommandInfoMap.put("clearRfid", doorLockclearRfidCommandInfo); + doorLockClusterInteractionInfoMap.put("clearRfid", doorLockclearRfidInteractionInfo); Map doorLockclearWeekdayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearWeekdaySchedulescheduleIdCommandParameterInfo = @@ -4913,8 +5224,8 @@ public Map getCommandMap(Map clusterMa "userId", doorLockclearWeekdayScheduleuserIdCommandParameterInfo); // Populate commands - CommandInfo doorLockclearWeekdayScheduleCommandInfo = - new CommandInfo( + InteractionInfo doorLockclearWeekdayScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .clearWeekdaySchedule( @@ -4924,8 +5235,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedClearWeekdayScheduleResponseCallback(), doorLockclearWeekdayScheduleCommandParams); - doorLockClusterCommandInfoMap.put( - "clearWeekdaySchedule", doorLockclearWeekdayScheduleCommandInfo); + doorLockClusterInteractionInfoMap.put( + "clearWeekdaySchedule", doorLockclearWeekdayScheduleInteractionInfo); Map doorLockclearYeardayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearYeardaySchedulescheduleIdCommandParameterInfo = @@ -4939,8 +5250,8 @@ public Map getCommandMap(Map clusterMa "userId", doorLockclearYeardayScheduleuserIdCommandParameterInfo); // Populate commands - CommandInfo doorLockclearYeardayScheduleCommandInfo = - new CommandInfo( + InteractionInfo doorLockclearYeardayScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .clearYeardaySchedule( @@ -4950,8 +5261,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedClearYeardayScheduleResponseCallback(), doorLockclearYeardayScheduleCommandParams); - doorLockClusterCommandInfoMap.put( - "clearYeardaySchedule", doorLockclearYeardayScheduleCommandInfo); + doorLockClusterInteractionInfoMap.put( + "clearYeardaySchedule", doorLockclearYeardayScheduleInteractionInfo); Map doorLockgetHolidayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetHolidaySchedulescheduleIdCommandParameterInfo = @@ -4960,8 +5271,8 @@ public Map getCommandMap(Map clusterMa "scheduleId", doorLockgetHolidaySchedulescheduleIdCommandParameterInfo); // Populate commands - CommandInfo doorLockgetHolidayScheduleCommandInfo = - new CommandInfo( + InteractionInfo doorLockgetHolidayScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getHolidaySchedule( @@ -4970,7 +5281,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetHolidayScheduleResponseCallback(), doorLockgetHolidayScheduleCommandParams); - doorLockClusterCommandInfoMap.put("getHolidaySchedule", doorLockgetHolidayScheduleCommandInfo); + doorLockClusterInteractionInfoMap.put( + "getHolidaySchedule", doorLockgetHolidayScheduleInteractionInfo); Map doorLockgetLogRecordCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetLogRecordlogIndexCommandParameterInfo = @@ -4979,8 +5291,8 @@ public Map getCommandMap(Map clusterMa "logIndex", doorLockgetLogRecordlogIndexCommandParameterInfo); // Populate commands - CommandInfo doorLockgetLogRecordCommandInfo = - new CommandInfo( + InteractionInfo doorLockgetLogRecordInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getLogRecord( @@ -4989,7 +5301,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetLogRecordResponseCallback(), doorLockgetLogRecordCommandParams); - doorLockClusterCommandInfoMap.put("getLogRecord", doorLockgetLogRecordCommandInfo); + doorLockClusterInteractionInfoMap.put("getLogRecord", doorLockgetLogRecordInteractionInfo); Map doorLockgetPinCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetPinuserIdCommandParameterInfo = @@ -4997,8 +5309,8 @@ public Map getCommandMap(Map clusterMa doorLockgetPinCommandParams.put("userId", doorLockgetPinuserIdCommandParameterInfo); // Populate commands - CommandInfo doorLockgetPinCommandInfo = - new CommandInfo( + InteractionInfo doorLockgetPinInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getPin( @@ -5007,7 +5319,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetPinResponseCallback(), doorLockgetPinCommandParams); - doorLockClusterCommandInfoMap.put("getPin", doorLockgetPinCommandInfo); + doorLockClusterInteractionInfoMap.put("getPin", doorLockgetPinInteractionInfo); Map doorLockgetRfidCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetRfiduserIdCommandParameterInfo = @@ -5015,8 +5327,8 @@ public Map getCommandMap(Map clusterMa doorLockgetRfidCommandParams.put("userId", doorLockgetRfiduserIdCommandParameterInfo); // Populate commands - CommandInfo doorLockgetRfidCommandInfo = - new CommandInfo( + InteractionInfo doorLockgetRfidInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getRfid( @@ -5025,7 +5337,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetRfidResponseCallback(), doorLockgetRfidCommandParams); - doorLockClusterCommandInfoMap.put("getRfid", doorLockgetRfidCommandInfo); + doorLockClusterInteractionInfoMap.put("getRfid", doorLockgetRfidInteractionInfo); Map doorLockgetUserTypeCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetUserTypeuserIdCommandParameterInfo = @@ -5033,8 +5345,8 @@ public Map getCommandMap(Map clusterMa doorLockgetUserTypeCommandParams.put("userId", doorLockgetUserTypeuserIdCommandParameterInfo); // Populate commands - CommandInfo doorLockgetUserTypeCommandInfo = - new CommandInfo( + InteractionInfo doorLockgetUserTypeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getUserType( @@ -5043,7 +5355,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetUserTypeResponseCallback(), doorLockgetUserTypeCommandParams); - doorLockClusterCommandInfoMap.put("getUserType", doorLockgetUserTypeCommandInfo); + doorLockClusterInteractionInfoMap.put("getUserType", doorLockgetUserTypeInteractionInfo); Map doorLockgetWeekdayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetWeekdaySchedulescheduleIdCommandParameterInfo = @@ -5057,8 +5369,8 @@ public Map getCommandMap(Map clusterMa "userId", doorLockgetWeekdayScheduleuserIdCommandParameterInfo); // Populate commands - CommandInfo doorLockgetWeekdayScheduleCommandInfo = - new CommandInfo( + InteractionInfo doorLockgetWeekdayScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getWeekdaySchedule( @@ -5068,7 +5380,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetWeekdayScheduleResponseCallback(), doorLockgetWeekdayScheduleCommandParams); - doorLockClusterCommandInfoMap.put("getWeekdaySchedule", doorLockgetWeekdayScheduleCommandInfo); + doorLockClusterInteractionInfoMap.put( + "getWeekdaySchedule", doorLockgetWeekdayScheduleInteractionInfo); Map doorLockgetYeardayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetYeardaySchedulescheduleIdCommandParameterInfo = @@ -5082,8 +5395,8 @@ public Map getCommandMap(Map clusterMa "userId", doorLockgetYeardayScheduleuserIdCommandParameterInfo); // Populate commands - CommandInfo doorLockgetYeardayScheduleCommandInfo = - new CommandInfo( + InteractionInfo doorLockgetYeardayScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getYeardaySchedule( @@ -5093,7 +5406,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetYeardayScheduleResponseCallback(), doorLockgetYeardayScheduleCommandParams); - doorLockClusterCommandInfoMap.put("getYeardaySchedule", doorLockgetYeardayScheduleCommandInfo); + doorLockClusterInteractionInfoMap.put( + "getYeardaySchedule", doorLockgetYeardayScheduleInteractionInfo); Map doorLocklockDoorCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocklockDoorpinCommandParameterInfo = @@ -5101,8 +5415,8 @@ public Map getCommandMap(Map clusterMa doorLocklockDoorCommandParams.put("pin", doorLocklockDoorpinCommandParameterInfo); // Populate commands - CommandInfo doorLocklockDoorCommandInfo = - new CommandInfo( + InteractionInfo doorLocklockDoorInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .lockDoor( @@ -5111,7 +5425,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedLockDoorResponseCallback(), doorLocklockDoorCommandParams); - doorLockClusterCommandInfoMap.put("lockDoor", doorLocklockDoorCommandInfo); + doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); Map doorLocksetHolidayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetHolidaySchedulescheduleIdCommandParameterInfo = @@ -5136,8 +5450,8 @@ public Map getCommandMap(Map clusterMa doorLocksetHolidayScheduleoperatingModeDuringHolidayCommandParameterInfo); // Populate commands - CommandInfo doorLocksetHolidayScheduleCommandInfo = - new CommandInfo( + InteractionInfo doorLocksetHolidayScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .setHolidaySchedule( @@ -5149,7 +5463,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedSetHolidayScheduleResponseCallback(), doorLocksetHolidayScheduleCommandParams); - doorLockClusterCommandInfoMap.put("setHolidaySchedule", doorLocksetHolidayScheduleCommandInfo); + doorLockClusterInteractionInfoMap.put( + "setHolidaySchedule", doorLocksetHolidayScheduleInteractionInfo); Map doorLocksetPinCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetPinuserIdCommandParameterInfo = @@ -5169,8 +5484,8 @@ public Map getCommandMap(Map clusterMa doorLocksetPinCommandParams.put("pin", doorLocksetPinpinCommandParameterInfo); // Populate commands - CommandInfo doorLocksetPinCommandInfo = - new CommandInfo( + InteractionInfo doorLocksetPinInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .setPin( @@ -5182,7 +5497,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedSetPinResponseCallback(), doorLocksetPinCommandParams); - doorLockClusterCommandInfoMap.put("setPin", doorLocksetPinCommandInfo); + doorLockClusterInteractionInfoMap.put("setPin", doorLocksetPinInteractionInfo); Map doorLocksetRfidCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetRfiduserIdCommandParameterInfo = @@ -5202,8 +5517,8 @@ public Map getCommandMap(Map clusterMa doorLocksetRfidCommandParams.put("id", doorLocksetRfididCommandParameterInfo); // Populate commands - CommandInfo doorLocksetRfidCommandInfo = - new CommandInfo( + InteractionInfo doorLocksetRfidInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .setRfid( @@ -5215,7 +5530,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedSetRfidResponseCallback(), doorLocksetRfidCommandParams); - doorLockClusterCommandInfoMap.put("setRfid", doorLocksetRfidCommandInfo); + doorLockClusterInteractionInfoMap.put("setRfid", doorLocksetRfidInteractionInfo); Map doorLocksetUserTypeCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetUserTypeuserIdCommandParameterInfo = @@ -5228,8 +5543,8 @@ public Map getCommandMap(Map clusterMa "userType", doorLocksetUserTypeuserTypeCommandParameterInfo); // Populate commands - CommandInfo doorLocksetUserTypeCommandInfo = - new CommandInfo( + InteractionInfo doorLocksetUserTypeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .setUserType( @@ -5239,7 +5554,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedSetUserTypeResponseCallback(), doorLocksetUserTypeCommandParams); - doorLockClusterCommandInfoMap.put("setUserType", doorLocksetUserTypeCommandInfo); + doorLockClusterInteractionInfoMap.put("setUserType", doorLocksetUserTypeInteractionInfo); Map doorLocksetWeekdayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetWeekdaySchedulescheduleIdCommandParameterInfo = @@ -5278,8 +5593,8 @@ public Map getCommandMap(Map clusterMa "endMinute", doorLocksetWeekdayScheduleendMinuteCommandParameterInfo); // Populate commands - CommandInfo doorLocksetWeekdayScheduleCommandInfo = - new CommandInfo( + InteractionInfo doorLocksetWeekdayScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .setWeekdaySchedule( @@ -5294,7 +5609,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedSetWeekdayScheduleResponseCallback(), doorLocksetWeekdayScheduleCommandParams); - doorLockClusterCommandInfoMap.put("setWeekdaySchedule", doorLocksetWeekdayScheduleCommandInfo); + doorLockClusterInteractionInfoMap.put( + "setWeekdaySchedule", doorLocksetWeekdayScheduleInteractionInfo); Map doorLocksetYeardayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetYeardaySchedulescheduleIdCommandParameterInfo = @@ -5318,8 +5634,8 @@ public Map getCommandMap(Map clusterMa "localEndTime", doorLocksetYeardaySchedulelocalEndTimeCommandParameterInfo); // Populate commands - CommandInfo doorLocksetYeardayScheduleCommandInfo = - new CommandInfo( + InteractionInfo doorLocksetYeardayScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .setYeardaySchedule( @@ -5331,7 +5647,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedSetYeardayScheduleResponseCallback(), doorLocksetYeardayScheduleCommandParams); - doorLockClusterCommandInfoMap.put("setYeardaySchedule", doorLocksetYeardayScheduleCommandInfo); + doorLockClusterInteractionInfoMap.put( + "setYeardaySchedule", doorLocksetYeardayScheduleInteractionInfo); Map doorLockunlockDoorCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockunlockDoorpinCommandParameterInfo = @@ -5339,8 +5656,8 @@ public Map getCommandMap(Map clusterMa doorLockunlockDoorCommandParams.put("pin", doorLockunlockDoorpinCommandParameterInfo); // Populate commands - CommandInfo doorLockunlockDoorCommandInfo = - new CommandInfo( + InteractionInfo doorLockunlockDoorInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .unlockDoor( @@ -5349,7 +5666,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedUnlockDoorResponseCallback(), doorLockunlockDoorCommandParams); - doorLockClusterCommandInfoMap.put("unlockDoor", doorLockunlockDoorCommandInfo); + doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); Map doorLockunlockWithTimeoutCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockunlockWithTimeouttimeoutInSecondsCommandParameterInfo = @@ -5363,8 +5680,8 @@ public Map getCommandMap(Map clusterMa "pin", doorLockunlockWithTimeoutpinCommandParameterInfo); // Populate commands - CommandInfo doorLockunlockWithTimeoutCommandInfo = - new CommandInfo( + InteractionInfo doorLockunlockWithTimeoutInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .unlockWithTimeout( @@ -5373,58 +5690,36 @@ public Map getCommandMap(Map clusterMa (byte[]) commandArguments.get("pin")); }, () -> new DelegatedUnlockWithTimeoutResponseCallback(), - doorLockunlockWithTimeoutCommandParams); - doorLockClusterCommandInfoMap.put("unlockWithTimeout", doorLockunlockWithTimeoutCommandInfo); - // Populate cluster - ClusterInfo doorLockClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), - doorLockClusterCommandInfoMap); - clusterMap.put("doorLock", doorLockClusterInfo); - Map electricalMeasurementClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo electricalMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), - electricalMeasurementClusterCommandInfoMap); - clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); - Map ethernetNetworkDiagnosticsClusterCommandInfoMap = - new LinkedHashMap<>(); - Map ethernetNetworkDiagnosticsresetCountsCommandParams = - new LinkedHashMap(); - // Populate commands - CommandInfo ethernetNetworkDiagnosticsresetCountsCommandInfo = - new CommandInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - ethernetNetworkDiagnosticsresetCountsCommandParams); - ethernetNetworkDiagnosticsClusterCommandInfoMap.put( - "resetCounts", ethernetNetworkDiagnosticsresetCountsCommandInfo); - // Populate cluster - ClusterInfo ethernetNetworkDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), - ethernetNetworkDiagnosticsClusterCommandInfoMap); - clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); - Map fixedLabelClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo fixedLabelClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), - fixedLabelClusterCommandInfoMap); - clusterMap.put("fixedLabel", fixedLabelClusterInfo); - Map flowMeasurementClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo flowMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), - flowMeasurementClusterCommandInfoMap); - clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); - Map generalCommissioningClusterCommandInfoMap = new LinkedHashMap<>(); + doorLockunlockWithTimeoutCommandParams); + doorLockClusterInteractionInfoMap.put( + "unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); + commandMap.put("doorLock", doorLockClusterInteractionInfoMap); + Map electricalMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); + Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map ethernetNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + // Populate commands + InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + ethernetNetworkDiagnosticsresetCountsCommandParams); + ethernetNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put( + "ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); + Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); + Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); + Map generalCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); Map generalCommissioningarmFailSafeCommandParams = new LinkedHashMap(); CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = @@ -5444,8 +5739,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); // Populate commands - CommandInfo generalCommissioningarmFailSafeCommandInfo = - new CommandInfo( + InteractionInfo generalCommissioningarmFailSafeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) .armFailSafe( @@ -5457,13 +5752,13 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedArmFailSafeResponseCallback(), generalCommissioningarmFailSafeCommandParams); - generalCommissioningClusterCommandInfoMap.put( - "armFailSafe", generalCommissioningarmFailSafeCommandInfo); + generalCommissioningClusterInteractionInfoMap.put( + "armFailSafe", generalCommissioningarmFailSafeInteractionInfo); Map generalCommissioningcommissioningCompleteCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo generalCommissioningcommissioningCompleteCommandInfo = - new CommandInfo( + InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) .commissioningComplete( @@ -5473,8 +5768,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedCommissioningCompleteResponseCallback(), generalCommissioningcommissioningCompleteCommandParams); - generalCommissioningClusterCommandInfoMap.put( - "commissioningComplete", generalCommissioningcommissioningCompleteCommandInfo); + generalCommissioningClusterInteractionInfoMap.put( + "commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); Map generalCommissioningsetRegulatoryConfigCommandParams = new LinkedHashMap(); CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = @@ -5498,8 +5793,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); // Populate commands - CommandInfo generalCommissioningsetRegulatoryConfigCommandInfo = - new CommandInfo( + InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) .setRegulatoryConfig( @@ -5512,29 +5807,16 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedSetRegulatoryConfigResponseCallback(), generalCommissioningsetRegulatoryConfigCommandParams); - generalCommissioningClusterCommandInfoMap.put( - "setRegulatoryConfig", generalCommissioningsetRegulatoryConfigCommandInfo); - // Populate cluster - ClusterInfo generalCommissioningClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), - generalCommissioningClusterCommandInfoMap); - clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); - Map generalDiagnosticsClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo generalDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), - generalDiagnosticsClusterCommandInfoMap); - clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); - Map groupKeyManagementClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo groupKeyManagementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), - groupKeyManagementClusterCommandInfoMap); - clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); - Map groupsClusterCommandInfoMap = new LinkedHashMap<>(); + generalCommissioningClusterInteractionInfoMap.put( + "setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); + commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); + Map generalDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); + Map groupKeyManagementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); + Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); Map groupsaddGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = @@ -5546,8 +5828,8 @@ public Map getCommandMap(Map clusterMa groupsaddGroupCommandParams.put("groupName", groupsaddGroupgroupNameCommandParameterInfo); // Populate commands - CommandInfo groupsaddGroupCommandInfo = - new CommandInfo( + InteractionInfo groupsaddGroupInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .addGroup( @@ -5557,7 +5839,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedAddGroupResponseCallback(), groupsaddGroupCommandParams); - groupsClusterCommandInfoMap.put("addGroup", groupsaddGroupCommandInfo); + groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); Map groupsaddGroupIfIdentifyingCommandParams = new LinkedHashMap(); CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = @@ -5571,8 +5853,8 @@ public Map getCommandMap(Map clusterMa "groupName", groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); // Populate commands - CommandInfo groupsaddGroupIfIdentifyingCommandInfo = - new CommandInfo( + InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .addGroupIfIdentifying( @@ -5582,8 +5864,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), groupsaddGroupIfIdentifyingCommandParams); - groupsClusterCommandInfoMap.put( - "addGroupIfIdentifying", groupsaddGroupIfIdentifyingCommandInfo); + groupsClusterInteractionInfoMap.put( + "addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); Map groupsgetGroupMembershipCommandParams = new LinkedHashMap(); CommandParameterInfo groupsgetGroupMembershipgroupCountCommandParameterInfo = @@ -5597,8 +5879,8 @@ public Map getCommandMap(Map clusterMa "groupList", groupsgetGroupMembershipgroupListCommandParameterInfo); // Populate commands - CommandInfo groupsgetGroupMembershipCommandInfo = - new CommandInfo( + InteractionInfo groupsgetGroupMembershipInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .getGroupMembership( @@ -5608,19 +5890,20 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetGroupMembershipResponseCallback(), groupsgetGroupMembershipCommandParams); - groupsClusterCommandInfoMap.put("getGroupMembership", groupsgetGroupMembershipCommandInfo); + groupsClusterInteractionInfoMap.put( + "getGroupMembership", groupsgetGroupMembershipInteractionInfo); Map groupsremoveAllGroupsCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo groupsremoveAllGroupsCommandInfo = - new CommandInfo( + InteractionInfo groupsremoveAllGroupsInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .removeAllGroups((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), groupsremoveAllGroupsCommandParams); - groupsClusterCommandInfoMap.put("removeAllGroups", groupsremoveAllGroupsCommandInfo); + groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); Map groupsremoveGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = @@ -5628,8 +5911,8 @@ public Map getCommandMap(Map clusterMa groupsremoveGroupCommandParams.put("groupId", groupsremoveGroupgroupIdCommandParameterInfo); // Populate commands - CommandInfo groupsremoveGroupCommandInfo = - new CommandInfo( + InteractionInfo groupsremoveGroupInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .removeGroup( @@ -5638,7 +5921,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedRemoveGroupResponseCallback(), groupsremoveGroupCommandParams); - groupsClusterCommandInfoMap.put("removeGroup", groupsremoveGroupCommandInfo); + groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); Map groupsviewGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = @@ -5646,8 +5929,8 @@ public Map getCommandMap(Map clusterMa groupsviewGroupCommandParams.put("groupId", groupsviewGroupgroupIdCommandParameterInfo); // Populate commands - CommandInfo groupsviewGroupCommandInfo = - new CommandInfo( + InteractionInfo groupsviewGroupInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .viewGroup( @@ -5656,14 +5939,9 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedViewGroupResponseCallback(), groupsviewGroupCommandParams); - groupsClusterCommandInfoMap.put("viewGroup", groupsviewGroupCommandInfo); - // Populate cluster - ClusterInfo groupsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), - groupsClusterCommandInfoMap); - clusterMap.put("groups", groupsClusterInfo); - Map identifyClusterCommandInfoMap = new LinkedHashMap<>(); + groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); + commandMap.put("groups", groupsClusterInteractionInfoMap); + Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); Map identifyidentifyCommandParams = new LinkedHashMap(); CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = @@ -5672,8 +5950,8 @@ public Map getCommandMap(Map clusterMa "identifyTime", identifyidentifyidentifyTimeCommandParameterInfo); // Populate commands - CommandInfo identifyidentifyCommandInfo = - new CommandInfo( + InteractionInfo identifyidentifyInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .identify( @@ -5682,12 +5960,12 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), identifyidentifyCommandParams); - identifyClusterCommandInfoMap.put("identify", identifyidentifyCommandInfo); + identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); Map identifyidentifyQueryCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo identifyidentifyQueryCommandInfo = - new CommandInfo( + InteractionInfo identifyidentifyQueryInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .identifyQuery( @@ -5695,7 +5973,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedIdentifyQueryResponseCallback(), identifyidentifyQueryCommandParams); - identifyClusterCommandInfoMap.put("identifyQuery", identifyidentifyQueryCommandInfo); + identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); Map identifytriggerEffectCommandParams = new LinkedHashMap(); CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = @@ -5709,8 +5987,8 @@ public Map getCommandMap(Map clusterMa "effectVariant", identifytriggerEffecteffectVariantCommandParameterInfo); // Populate commands - CommandInfo identifytriggerEffectCommandInfo = - new CommandInfo( + InteractionInfo identifytriggerEffectInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .triggerEffect( @@ -5720,21 +5998,12 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), identifytriggerEffectCommandParams); - identifyClusterCommandInfoMap.put("triggerEffect", identifytriggerEffectCommandInfo); - // Populate cluster - ClusterInfo identifyClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), - identifyClusterCommandInfoMap); - clusterMap.put("identify", identifyClusterInfo); - Map illuminanceMeasurementClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo illuminanceMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), - illuminanceMeasurementClusterCommandInfoMap); - clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); - Map keypadInputClusterCommandInfoMap = new LinkedHashMap<>(); + identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); + commandMap.put("identify", identifyClusterInteractionInfoMap); + Map illuminanceMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); + Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); Map keypadInputsendKeyCommandParams = new LinkedHashMap(); CommandParameterInfo keypadInputsendKeykeyCodeCommandParameterInfo = @@ -5742,8 +6011,8 @@ public Map getCommandMap(Map clusterMa keypadInputsendKeyCommandParams.put("keyCode", keypadInputsendKeykeyCodeCommandParameterInfo); // Populate commands - CommandInfo keypadInputsendKeyCommandInfo = - new CommandInfo( + InteractionInfo keypadInputsendKeyInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.KeypadInputCluster) cluster) .sendKey( @@ -5752,14 +6021,9 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedSendKeyResponseCallback(), keypadInputsendKeyCommandParams); - keypadInputClusterCommandInfoMap.put("sendKey", keypadInputsendKeyCommandInfo); - // Populate cluster - ClusterInfo keypadInputClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), - keypadInputClusterCommandInfoMap); - clusterMap.put("keypadInput", keypadInputClusterInfo); - Map levelControlClusterCommandInfoMap = new LinkedHashMap<>(); + keypadInputClusterInteractionInfoMap.put("sendKey", keypadInputsendKeyInteractionInfo); + commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); + Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); Map levelControlmoveCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = @@ -5780,8 +6044,8 @@ public Map getCommandMap(Map clusterMa "optionOverride", levelControlmoveoptionOverrideCommandParameterInfo); // Populate commands - CommandInfo levelControlmoveCommandInfo = - new CommandInfo( + InteractionInfo levelControlmoveInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .move( @@ -5793,7 +6057,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), levelControlmoveCommandParams); - levelControlClusterCommandInfoMap.put("move", levelControlmoveCommandInfo); + levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); Map levelControlmoveToLevelCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = @@ -5817,8 +6081,8 @@ public Map getCommandMap(Map clusterMa "optionOverride", levelControlmoveToLeveloptionOverrideCommandParameterInfo); // Populate commands - CommandInfo levelControlmoveToLevelCommandInfo = - new CommandInfo( + InteractionInfo levelControlmoveToLevelInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .moveToLevel( @@ -5830,7 +6094,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), levelControlmoveToLevelCommandParams); - levelControlClusterCommandInfoMap.put("moveToLevel", levelControlmoveToLevelCommandInfo); + levelControlClusterInteractionInfoMap.put( + "moveToLevel", levelControlmoveToLevelInteractionInfo); Map levelControlmoveToLevelWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = @@ -5844,8 +6109,8 @@ public Map getCommandMap(Map clusterMa "transitionTime", levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); // Populate commands - CommandInfo levelControlmoveToLevelWithOnOffCommandInfo = - new CommandInfo( + InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .moveToLevelWithOnOff( @@ -5855,8 +6120,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), levelControlmoveToLevelWithOnOffCommandParams); - levelControlClusterCommandInfoMap.put( - "moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffCommandInfo); + levelControlClusterInteractionInfoMap.put( + "moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); Map levelControlmoveWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = @@ -5870,8 +6135,8 @@ public Map getCommandMap(Map clusterMa "rate", levelControlmoveWithOnOffrateCommandParameterInfo); // Populate commands - CommandInfo levelControlmoveWithOnOffCommandInfo = - new CommandInfo( + InteractionInfo levelControlmoveWithOnOffInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .moveWithOnOff( @@ -5881,7 +6146,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), levelControlmoveWithOnOffCommandParams); - levelControlClusterCommandInfoMap.put("moveWithOnOff", levelControlmoveWithOnOffCommandInfo); + levelControlClusterInteractionInfoMap.put( + "moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); Map levelControlstepCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstepstepModeCommandParameterInfo = @@ -5907,8 +6173,8 @@ public Map getCommandMap(Map clusterMa "optionOverride", levelControlstepoptionOverrideCommandParameterInfo); // Populate commands - CommandInfo levelControlstepCommandInfo = - new CommandInfo( + InteractionInfo levelControlstepInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .step( @@ -5921,7 +6187,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), levelControlstepCommandParams); - levelControlClusterCommandInfoMap.put("step", levelControlstepCommandInfo); + levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); Map levelControlstepWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = @@ -5940,8 +6206,8 @@ public Map getCommandMap(Map clusterMa "transitionTime", levelControlstepWithOnOfftransitionTimeCommandParameterInfo); // Populate commands - CommandInfo levelControlstepWithOnOffCommandInfo = - new CommandInfo( + InteractionInfo levelControlstepWithOnOffInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .stepWithOnOff( @@ -5952,7 +6218,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), levelControlstepWithOnOffCommandParams); - levelControlClusterCommandInfoMap.put("stepWithOnOff", levelControlstepWithOnOffCommandInfo); + levelControlClusterInteractionInfoMap.put( + "stepWithOnOff", levelControlstepWithOnOffInteractionInfo); Map levelControlstopCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = @@ -5965,8 +6232,8 @@ public Map getCommandMap(Map clusterMa "optionOverride", levelControlstopoptionOverrideCommandParameterInfo); // Populate commands - CommandInfo levelControlstopCommandInfo = - new CommandInfo( + InteractionInfo levelControlstopInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .stop( @@ -5976,56 +6243,48 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), levelControlstopCommandParams); - levelControlClusterCommandInfoMap.put("stop", levelControlstopCommandInfo); + levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); Map levelControlstopWithOnOffCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo levelControlstopWithOnOffCommandInfo = - new CommandInfo( + InteractionInfo levelControlstopWithOnOffInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .stopWithOnOff((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), levelControlstopWithOnOffCommandParams); - levelControlClusterCommandInfoMap.put("stopWithOnOff", levelControlstopWithOnOffCommandInfo); - // Populate cluster - ClusterInfo levelControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), - levelControlClusterCommandInfoMap); - clusterMap.put("levelControl", levelControlClusterInfo); - Map lowPowerClusterCommandInfoMap = new LinkedHashMap<>(); + levelControlClusterInteractionInfoMap.put( + "stopWithOnOff", levelControlstopWithOnOffInteractionInfo); + commandMap.put("levelControl", levelControlClusterInteractionInfoMap); + Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); Map lowPowersleepCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo lowPowersleepCommandInfo = - new CommandInfo( + InteractionInfo lowPowersleepInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LowPowerCluster) cluster).sleep((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), lowPowersleepCommandParams); - lowPowerClusterCommandInfoMap.put("sleep", lowPowersleepCommandInfo); - // Populate cluster - ClusterInfo lowPowerClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), - lowPowerClusterCommandInfoMap); - clusterMap.put("lowPower", lowPowerClusterInfo); - Map mediaInputClusterCommandInfoMap = new LinkedHashMap<>(); + lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); + commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); + Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); Map mediaInputhideInputStatusCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaInputhideInputStatusCommandInfo = - new CommandInfo( + InteractionInfo mediaInputhideInputStatusInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .hideInputStatus((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), mediaInputhideInputStatusCommandParams); - mediaInputClusterCommandInfoMap.put("hideInputStatus", mediaInputhideInputStatusCommandInfo); + mediaInputClusterInteractionInfoMap.put( + "hideInputStatus", mediaInputhideInputStatusInteractionInfo); Map mediaInputrenameInputCommandParams = new LinkedHashMap(); CommandParameterInfo mediaInputrenameInputindexCommandParameterInfo = @@ -6037,8 +6296,8 @@ public Map getCommandMap(Map clusterMa mediaInputrenameInputCommandParams.put("name", mediaInputrenameInputnameCommandParameterInfo); // Populate commands - CommandInfo mediaInputrenameInputCommandInfo = - new CommandInfo( + InteractionInfo mediaInputrenameInputInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .renameInput( @@ -6048,7 +6307,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), mediaInputrenameInputCommandParams); - mediaInputClusterCommandInfoMap.put("renameInput", mediaInputrenameInputCommandInfo); + mediaInputClusterInteractionInfoMap.put("renameInput", mediaInputrenameInputInteractionInfo); Map mediaInputselectInputCommandParams = new LinkedHashMap(); CommandParameterInfo mediaInputselectInputindexCommandParameterInfo = @@ -6056,8 +6315,8 @@ public Map getCommandMap(Map clusterMa mediaInputselectInputCommandParams.put("index", mediaInputselectInputindexCommandParameterInfo); // Populate commands - CommandInfo mediaInputselectInputCommandInfo = - new CommandInfo( + InteractionInfo mediaInputselectInputInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .selectInput( @@ -6065,31 +6324,27 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), mediaInputselectInputCommandParams); - mediaInputClusterCommandInfoMap.put("selectInput", mediaInputselectInputCommandInfo); + mediaInputClusterInteractionInfoMap.put("selectInput", mediaInputselectInputInteractionInfo); Map mediaInputshowInputStatusCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaInputshowInputStatusCommandInfo = - new CommandInfo( + InteractionInfo mediaInputshowInputStatusInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .showInputStatus((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), mediaInputshowInputStatusCommandParams); - mediaInputClusterCommandInfoMap.put("showInputStatus", mediaInputshowInputStatusCommandInfo); - // Populate cluster - ClusterInfo mediaInputClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), - mediaInputClusterCommandInfoMap); - clusterMap.put("mediaInput", mediaInputClusterInfo); - Map mediaPlaybackClusterCommandInfoMap = new LinkedHashMap<>(); + mediaInputClusterInteractionInfoMap.put( + "showInputStatus", mediaInputshowInputStatusInteractionInfo); + commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); + Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); Map mediaPlaybackmediaFastForwardCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaPlaybackmediaFastForwardCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaFastForwardInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaFastForward( @@ -6098,13 +6353,13 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaFastForwardResponseCallback(), mediaPlaybackmediaFastForwardCommandParams); - mediaPlaybackClusterCommandInfoMap.put( - "mediaFastForward", mediaPlaybackmediaFastForwardCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put( + "mediaFastForward", mediaPlaybackmediaFastForwardInteractionInfo); Map mediaPlaybackmediaNextCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaPlaybackmediaNextCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaNextInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaNext( @@ -6112,12 +6367,12 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaNextResponseCallback(), mediaPlaybackmediaNextCommandParams); - mediaPlaybackClusterCommandInfoMap.put("mediaNext", mediaPlaybackmediaNextCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put("mediaNext", mediaPlaybackmediaNextInteractionInfo); Map mediaPlaybackmediaPauseCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaPlaybackmediaPauseCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaPauseInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaPause( @@ -6125,12 +6380,13 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaPauseResponseCallback(), mediaPlaybackmediaPauseCommandParams); - mediaPlaybackClusterCommandInfoMap.put("mediaPause", mediaPlaybackmediaPauseCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put( + "mediaPause", mediaPlaybackmediaPauseInteractionInfo); Map mediaPlaybackmediaPlayCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaPlaybackmediaPlayCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaPlayInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaPlay( @@ -6138,12 +6394,12 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaPlayResponseCallback(), mediaPlaybackmediaPlayCommandParams); - mediaPlaybackClusterCommandInfoMap.put("mediaPlay", mediaPlaybackmediaPlayCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put("mediaPlay", mediaPlaybackmediaPlayInteractionInfo); Map mediaPlaybackmediaPreviousCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaPlaybackmediaPreviousCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaPreviousInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaPrevious( @@ -6151,12 +6407,13 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaPreviousResponseCallback(), mediaPlaybackmediaPreviousCommandParams); - mediaPlaybackClusterCommandInfoMap.put("mediaPrevious", mediaPlaybackmediaPreviousCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put( + "mediaPrevious", mediaPlaybackmediaPreviousInteractionInfo); Map mediaPlaybackmediaRewindCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaPlaybackmediaRewindCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaRewindInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaRewind( @@ -6164,7 +6421,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaRewindResponseCallback(), mediaPlaybackmediaRewindCommandParams); - mediaPlaybackClusterCommandInfoMap.put("mediaRewind", mediaPlaybackmediaRewindCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put( + "mediaRewind", mediaPlaybackmediaRewindInteractionInfo); Map mediaPlaybackmediaSeekCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackmediaSeekpositionCommandParameterInfo = @@ -6173,8 +6431,8 @@ public Map getCommandMap(Map clusterMa "position", mediaPlaybackmediaSeekpositionCommandParameterInfo); // Populate commands - CommandInfo mediaPlaybackmediaSeekCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaSeekInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaSeek( @@ -6183,7 +6441,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaSeekResponseCallback(), mediaPlaybackmediaSeekCommandParams); - mediaPlaybackClusterCommandInfoMap.put("mediaSeek", mediaPlaybackmediaSeekCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put("mediaSeek", mediaPlaybackmediaSeekInteractionInfo); Map mediaPlaybackmediaSkipBackwardCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -6194,8 +6452,8 @@ public Map getCommandMap(Map clusterMa mediaPlaybackmediaSkipBackwarddeltaPositionMillisecondsCommandParameterInfo); // Populate commands - CommandInfo mediaPlaybackmediaSkipBackwardCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaSkipBackwardInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaSkipBackward( @@ -6205,8 +6463,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaSkipBackwardResponseCallback(), mediaPlaybackmediaSkipBackwardCommandParams); - mediaPlaybackClusterCommandInfoMap.put( - "mediaSkipBackward", mediaPlaybackmediaSkipBackwardCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put( + "mediaSkipBackward", mediaPlaybackmediaSkipBackwardInteractionInfo); Map mediaPlaybackmediaSkipForwardCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -6217,8 +6475,8 @@ public Map getCommandMap(Map clusterMa mediaPlaybackmediaSkipForwarddeltaPositionMillisecondsCommandParameterInfo); // Populate commands - CommandInfo mediaPlaybackmediaSkipForwardCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaSkipForwardInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaSkipForward( @@ -6227,13 +6485,13 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaSkipForwardResponseCallback(), mediaPlaybackmediaSkipForwardCommandParams); - mediaPlaybackClusterCommandInfoMap.put( - "mediaSkipForward", mediaPlaybackmediaSkipForwardCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put( + "mediaSkipForward", mediaPlaybackmediaSkipForwardInteractionInfo); Map mediaPlaybackmediaStartOverCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaPlaybackmediaStartOverCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaStartOverInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaStartOver( @@ -6241,13 +6499,13 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaStartOverResponseCallback(), mediaPlaybackmediaStartOverCommandParams); - mediaPlaybackClusterCommandInfoMap.put( - "mediaStartOver", mediaPlaybackmediaStartOverCommandInfo); + mediaPlaybackClusterInteractionInfoMap.put( + "mediaStartOver", mediaPlaybackmediaStartOverInteractionInfo); Map mediaPlaybackmediaStopCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo mediaPlaybackmediaStopCommandInfo = - new CommandInfo( + InteractionInfo mediaPlaybackmediaStopInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .mediaStop( @@ -6255,14 +6513,9 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedMediaStopResponseCallback(), mediaPlaybackmediaStopCommandParams); - mediaPlaybackClusterCommandInfoMap.put("mediaStop", mediaPlaybackmediaStopCommandInfo); - // Populate cluster - ClusterInfo mediaPlaybackClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), - mediaPlaybackClusterCommandInfoMap); - clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); - Map modeSelectClusterCommandInfoMap = new LinkedHashMap<>(); + mediaPlaybackClusterInteractionInfoMap.put("mediaStop", mediaPlaybackmediaStopInteractionInfo); + commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); + Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); Map modeSelectchangeToModeCommandParams = new LinkedHashMap(); CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = @@ -6271,8 +6524,8 @@ public Map getCommandMap(Map clusterMa "newMode", modeSelectchangeToModenewModeCommandParameterInfo); // Populate commands - CommandInfo modeSelectchangeToModeCommandInfo = - new CommandInfo( + InteractionInfo modeSelectchangeToModeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .changeToMode( @@ -6280,14 +6533,10 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), modeSelectchangeToModeCommandParams); - modeSelectClusterCommandInfoMap.put("changeToMode", modeSelectchangeToModeCommandInfo); - // Populate cluster - ClusterInfo modeSelectClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), - modeSelectClusterCommandInfoMap); - clusterMap.put("modeSelect", modeSelectClusterInfo); - Map networkCommissioningClusterCommandInfoMap = new LinkedHashMap<>(); + modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); + commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); + Map networkCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); Map networkCommissioningaddThreadNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -6308,8 +6557,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", networkCommissioningaddThreadNetworktimeoutMsCommandParameterInfo); // Populate commands - CommandInfo networkCommissioningaddThreadNetworkCommandInfo = - new CommandInfo( + InteractionInfo networkCommissioningaddThreadNetworkInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .addThreadNetwork( @@ -6321,8 +6570,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedAddThreadNetworkResponseCallback(), networkCommissioningaddThreadNetworkCommandParams); - networkCommissioningClusterCommandInfoMap.put( - "addThreadNetwork", networkCommissioningaddThreadNetworkCommandInfo); + networkCommissioningClusterInteractionInfoMap.put( + "addThreadNetwork", networkCommissioningaddThreadNetworkInteractionInfo); Map networkCommissioningaddWiFiNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningaddWiFiNetworkssidCommandParameterInfo = @@ -6346,8 +6595,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", networkCommissioningaddWiFiNetworktimeoutMsCommandParameterInfo); // Populate commands - CommandInfo networkCommissioningaddWiFiNetworkCommandInfo = - new CommandInfo( + InteractionInfo networkCommissioningaddWiFiNetworkInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .addWiFiNetwork( @@ -6360,8 +6609,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedAddWiFiNetworkResponseCallback(), networkCommissioningaddWiFiNetworkCommandParams); - networkCommissioningClusterCommandInfoMap.put( - "addWiFiNetwork", networkCommissioningaddWiFiNetworkCommandInfo); + networkCommissioningClusterInteractionInfoMap.put( + "addWiFiNetwork", networkCommissioningaddWiFiNetworkInteractionInfo); Map networkCommissioningdisableNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningdisableNetworknetworkIDCommandParameterInfo = @@ -6380,8 +6629,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", networkCommissioningdisableNetworktimeoutMsCommandParameterInfo); // Populate commands - CommandInfo networkCommissioningdisableNetworkCommandInfo = - new CommandInfo( + InteractionInfo networkCommissioningdisableNetworkInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .disableNetwork( @@ -6393,8 +6642,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDisableNetworkResponseCallback(), networkCommissioningdisableNetworkCommandParams); - networkCommissioningClusterCommandInfoMap.put( - "disableNetwork", networkCommissioningdisableNetworkCommandInfo); + networkCommissioningClusterInteractionInfoMap.put( + "disableNetwork", networkCommissioningdisableNetworkInteractionInfo); Map networkCommissioningenableNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningenableNetworknetworkIDCommandParameterInfo = @@ -6413,8 +6662,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", networkCommissioningenableNetworktimeoutMsCommandParameterInfo); // Populate commands - CommandInfo networkCommissioningenableNetworkCommandInfo = - new CommandInfo( + InteractionInfo networkCommissioningenableNetworkInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .enableNetwork( @@ -6426,8 +6675,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedEnableNetworkResponseCallback(), networkCommissioningenableNetworkCommandParams); - networkCommissioningClusterCommandInfoMap.put( - "enableNetwork", networkCommissioningenableNetworkCommandInfo); + networkCommissioningClusterInteractionInfoMap.put( + "enableNetwork", networkCommissioningenableNetworkInteractionInfo); Map networkCommissioningremoveNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = @@ -6446,8 +6695,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", networkCommissioningremoveNetworktimeoutMsCommandParameterInfo); // Populate commands - CommandInfo networkCommissioningremoveNetworkCommandInfo = - new CommandInfo( + InteractionInfo networkCommissioningremoveNetworkInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .removeNetwork( @@ -6459,8 +6708,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedRemoveNetworkResponseCallback(), networkCommissioningremoveNetworkCommandParams); - networkCommissioningClusterCommandInfoMap.put( - "removeNetwork", networkCommissioningremoveNetworkCommandInfo); + networkCommissioningClusterInteractionInfoMap.put( + "removeNetwork", networkCommissioningremoveNetworkInteractionInfo); Map networkCommissioningscanNetworksCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = @@ -6479,8 +6728,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", networkCommissioningscanNetworkstimeoutMsCommandParameterInfo); // Populate commands - CommandInfo networkCommissioningscanNetworksCommandInfo = - new CommandInfo( + InteractionInfo networkCommissioningscanNetworksInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .scanNetworks( @@ -6492,8 +6741,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedScanNetworksResponseCallback(), networkCommissioningscanNetworksCommandParams); - networkCommissioningClusterCommandInfoMap.put( - "scanNetworks", networkCommissioningscanNetworksCommandInfo); + networkCommissioningClusterInteractionInfoMap.put( + "scanNetworks", networkCommissioningscanNetworksInteractionInfo); Map networkCommissioningupdateThreadNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -6514,8 +6763,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", networkCommissioningupdateThreadNetworktimeoutMsCommandParameterInfo); // Populate commands - CommandInfo networkCommissioningupdateThreadNetworkCommandInfo = - new CommandInfo( + InteractionInfo networkCommissioningupdateThreadNetworkInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .updateThreadNetwork( @@ -6527,8 +6776,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedUpdateThreadNetworkResponseCallback(), networkCommissioningupdateThreadNetworkCommandParams); - networkCommissioningClusterCommandInfoMap.put( - "updateThreadNetwork", networkCommissioningupdateThreadNetworkCommandInfo); + networkCommissioningClusterInteractionInfoMap.put( + "updateThreadNetwork", networkCommissioningupdateThreadNetworkInteractionInfo); Map networkCommissioningupdateWiFiNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningupdateWiFiNetworkssidCommandParameterInfo = @@ -6552,8 +6801,8 @@ public Map getCommandMap(Map clusterMa "timeoutMs", networkCommissioningupdateWiFiNetworktimeoutMsCommandParameterInfo); // Populate commands - CommandInfo networkCommissioningupdateWiFiNetworkCommandInfo = - new CommandInfo( + InteractionInfo networkCommissioningupdateWiFiNetworkInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .updateWiFiNetwork( @@ -6566,15 +6815,11 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedUpdateWiFiNetworkResponseCallback(), networkCommissioningupdateWiFiNetworkCommandParams); - networkCommissioningClusterCommandInfoMap.put( - "updateWiFiNetwork", networkCommissioningupdateWiFiNetworkCommandInfo); - // Populate cluster - ClusterInfo networkCommissioningClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), - networkCommissioningClusterCommandInfoMap); - clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); - Map otaSoftwareUpdateProviderClusterCommandInfoMap = new LinkedHashMap<>(); + networkCommissioningClusterInteractionInfoMap.put( + "updateWiFiNetwork", networkCommissioningupdateWiFiNetworkInteractionInfo); + commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); + Map otaSoftwareUpdateProviderClusterInteractionInfoMap = + new LinkedHashMap<>(); Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -6589,8 +6834,8 @@ public Map getCommandMap(Map clusterMa "newVersion", otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); // Populate commands - CommandInfo otaSoftwareUpdateProviderapplyUpdateRequestCommandInfo = - new CommandInfo( + InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) .applyUpdateRequest( @@ -6601,8 +6846,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedApplyUpdateResponseCallback(), otaSoftwareUpdateProviderapplyUpdateRequestCommandParams); - otaSoftwareUpdateProviderClusterCommandInfoMap.put( - "applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestCommandInfo); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -6619,8 +6864,8 @@ public Map getCommandMap(Map clusterMa otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); // Populate commands - CommandInfo otaSoftwareUpdateProvidernotifyUpdateAppliedCommandInfo = - new CommandInfo( + InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) .notifyUpdateApplied( @@ -6630,8 +6875,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams); - otaSoftwareUpdateProviderClusterCommandInfoMap.put( - "notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedCommandInfo); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); Map otaSoftwareUpdateProviderqueryImageCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = @@ -6680,8 +6925,8 @@ public Map getCommandMap(Map clusterMa otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); // Populate commands - CommandInfo otaSoftwareUpdateProviderqueryImageCommandInfo = - new CommandInfo( + InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) .queryImage( @@ -6698,15 +6943,10 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedQueryImageResponseCallback(), otaSoftwareUpdateProviderqueryImageCommandParams); - otaSoftwareUpdateProviderClusterCommandInfoMap.put( - "queryImage", otaSoftwareUpdateProviderqueryImageCommandInfo); - // Populate cluster - ClusterInfo otaSoftwareUpdateProviderClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), - otaSoftwareUpdateProviderClusterCommandInfoMap); - clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); - Map otaSoftwareUpdateRequestorClusterCommandInfoMap = + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); + commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); + Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = new LinkedHashMap<>(); Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = new LinkedHashMap(); @@ -6737,8 +6977,8 @@ public Map getCommandMap(Map clusterMa otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); // Populate commands - CommandInfo otaSoftwareUpdateRequestorannounceOtaProviderCommandInfo = - new CommandInfo( + InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) .announceOtaProvider( @@ -6750,34 +6990,24 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), otaSoftwareUpdateRequestorannounceOtaProviderCommandParams); - otaSoftwareUpdateRequestorClusterCommandInfoMap.put( - "announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderCommandInfo); - // Populate cluster - ClusterInfo otaSoftwareUpdateRequestorClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), - otaSoftwareUpdateRequestorClusterCommandInfoMap); - clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); - Map occupancySensingClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo occupancySensingClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), - occupancySensingClusterCommandInfoMap); - clusterMap.put("occupancySensing", occupancySensingClusterInfo); - Map onOffClusterCommandInfoMap = new LinkedHashMap<>(); + otaSoftwareUpdateRequestorClusterInteractionInfoMap.put( + "announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); + commandMap.put( + "otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); + Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); + Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); Map onOffoffCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo onOffoffCommandInfo = - new CommandInfo( + InteractionInfo onOffoffInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster).off((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), onOffoffCommandParams); - onOffClusterCommandInfoMap.put("off", onOffoffCommandInfo); + onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); Map onOffoffWithEffectCommandParams = new LinkedHashMap(); CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = @@ -6790,8 +7020,8 @@ public Map getCommandMap(Map clusterMa "effectVariant", onOffoffWithEffecteffectVariantCommandParameterInfo); // Populate commands - CommandInfo onOffoffWithEffectCommandInfo = - new CommandInfo( + InteractionInfo onOffoffWithEffectInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .offWithEffect( @@ -6801,31 +7031,31 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), onOffoffWithEffectCommandParams); - onOffClusterCommandInfoMap.put("offWithEffect", onOffoffWithEffectCommandInfo); + onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); Map onOffonCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo onOffonCommandInfo = - new CommandInfo( + InteractionInfo onOffonInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster).on((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), onOffonCommandParams); - onOffClusterCommandInfoMap.put("on", onOffonCommandInfo); + onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); Map onOffonWithRecallGlobalSceneCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo onOffonWithRecallGlobalSceneCommandInfo = - new CommandInfo( + InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .onWithRecallGlobalScene((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), onOffonWithRecallGlobalSceneCommandParams); - onOffClusterCommandInfoMap.put( - "onWithRecallGlobalScene", onOffonWithRecallGlobalSceneCommandInfo); + onOffClusterInteractionInfoMap.put( + "onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); Map onOffonWithTimedOffCommandParams = new LinkedHashMap(); CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = @@ -6843,8 +7073,8 @@ public Map getCommandMap(Map clusterMa "offWaitTime", onOffonWithTimedOffoffWaitTimeCommandParameterInfo); // Populate commands - CommandInfo onOffonWithTimedOffCommandInfo = - new CommandInfo( + InteractionInfo onOffonWithTimedOffInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .onWithTimedOff( @@ -6855,32 +7085,24 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), onOffonWithTimedOffCommandParams); - onOffClusterCommandInfoMap.put("onWithTimedOff", onOffonWithTimedOffCommandInfo); + onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); Map onOfftoggleCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo onOfftoggleCommandInfo = - new CommandInfo( + InteractionInfo onOfftoggleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster).toggle((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), onOfftoggleCommandParams); - onOffClusterCommandInfoMap.put("toggle", onOfftoggleCommandInfo); - // Populate cluster - ClusterInfo onOffClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), - onOffClusterCommandInfoMap); - clusterMap.put("onOff", onOffClusterInfo); - Map onOffSwitchConfigurationClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo onOffSwitchConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), - onOffSwitchConfigurationClusterCommandInfoMap); - clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); - Map operationalCredentialsClusterCommandInfoMap = new LinkedHashMap<>(); + onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); + commandMap.put("onOff", onOffClusterInteractionInfoMap); + Map onOffSwitchConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); + Map operationalCredentialsClusterInteractionInfoMap = + new LinkedHashMap<>(); Map operationalCredentialsaddNOCCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = @@ -6909,8 +7131,8 @@ public Map getCommandMap(Map clusterMa "adminVendorId", operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); // Populate commands - CommandInfo operationalCredentialsaddNOCCommandInfo = - new CommandInfo( + InteractionInfo operationalCredentialsaddNOCInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .addNOC( @@ -6923,8 +7145,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedNOCResponseCallback(), operationalCredentialsaddNOCCommandParams); - operationalCredentialsClusterCommandInfoMap.put( - "addNOC", operationalCredentialsaddNOCCommandInfo); + operationalCredentialsClusterInteractionInfoMap.put( + "addNOC", operationalCredentialsaddNOCInteractionInfo); Map operationalCredentialsaddTrustedRootCertificateCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -6935,8 +7157,8 @@ public Map getCommandMap(Map clusterMa operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); // Populate commands - CommandInfo operationalCredentialsaddTrustedRootCertificateCommandInfo = - new CommandInfo( + InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .addTrustedRootCertificate( @@ -6945,8 +7167,9 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), operationalCredentialsaddTrustedRootCertificateCommandParams); - operationalCredentialsClusterCommandInfoMap.put( - "addTrustedRootCertificate", operationalCredentialsaddTrustedRootCertificateCommandInfo); + operationalCredentialsClusterInteractionInfoMap.put( + "addTrustedRootCertificate", + operationalCredentialsaddTrustedRootCertificateInteractionInfo); Map operationalCredentialsattestationRequestCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -6957,8 +7180,8 @@ public Map getCommandMap(Map clusterMa operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); // Populate commands - CommandInfo operationalCredentialsattestationRequestCommandInfo = - new CommandInfo( + InteractionInfo operationalCredentialsattestationRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .attestationRequest( @@ -6968,8 +7191,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedAttestationResponseCallback(), operationalCredentialsattestationRequestCommandParams); - operationalCredentialsClusterCommandInfoMap.put( - "attestationRequest", operationalCredentialsattestationRequestCommandInfo); + operationalCredentialsClusterInteractionInfoMap.put( + "attestationRequest", operationalCredentialsattestationRequestInteractionInfo); Map operationalCredentialscertificateChainRequestCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -6980,8 +7203,8 @@ public Map getCommandMap(Map clusterMa operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); // Populate commands - CommandInfo operationalCredentialscertificateChainRequestCommandInfo = - new CommandInfo( + InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .certificateChainRequest( @@ -6991,8 +7214,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedCertificateChainResponseCallback(), operationalCredentialscertificateChainRequestCommandParams); - operationalCredentialsClusterCommandInfoMap.put( - "certificateChainRequest", operationalCredentialscertificateChainRequestCommandInfo); + operationalCredentialsClusterInteractionInfoMap.put( + "certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); Map operationalCredentialsopCSRRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = @@ -7001,8 +7224,8 @@ public Map getCommandMap(Map clusterMa "CSRNonce", operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); // Populate commands - CommandInfo operationalCredentialsopCSRRequestCommandInfo = - new CommandInfo( + InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .opCSRRequest( @@ -7011,8 +7234,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedOpCSRResponseCallback(), operationalCredentialsopCSRRequestCommandParams); - operationalCredentialsClusterCommandInfoMap.put( - "opCSRRequest", operationalCredentialsopCSRRequestCommandInfo); + operationalCredentialsClusterInteractionInfoMap.put( + "opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); Map operationalCredentialsremoveFabricCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = @@ -7021,8 +7244,8 @@ public Map getCommandMap(Map clusterMa "fabricIndex", operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); // Populate commands - CommandInfo operationalCredentialsremoveFabricCommandInfo = - new CommandInfo( + InteractionInfo operationalCredentialsremoveFabricInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .removeFabric( @@ -7031,8 +7254,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedNOCResponseCallback(), operationalCredentialsremoveFabricCommandParams); - operationalCredentialsClusterCommandInfoMap.put( - "removeFabric", operationalCredentialsremoveFabricCommandInfo); + operationalCredentialsClusterInteractionInfoMap.put( + "removeFabric", operationalCredentialsremoveFabricInteractionInfo); Map operationalCredentialsremoveTrustedRootCertificateCommandParams = new LinkedHashMap(); @@ -7044,8 +7267,8 @@ public Map getCommandMap(Map clusterMa operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); // Populate commands - CommandInfo operationalCredentialsremoveTrustedRootCertificateCommandInfo = - new CommandInfo( + InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .removeTrustedRootCertificate( @@ -7054,9 +7277,9 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), operationalCredentialsremoveTrustedRootCertificateCommandParams); - operationalCredentialsClusterCommandInfoMap.put( + operationalCredentialsClusterInteractionInfoMap.put( "removeTrustedRootCertificate", - operationalCredentialsremoveTrustedRootCertificateCommandInfo); + operationalCredentialsremoveTrustedRootCertificateInteractionInfo); Map operationalCredentialsupdateFabricLabelCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = @@ -7065,8 +7288,8 @@ public Map getCommandMap(Map clusterMa "label", operationalCredentialsupdateFabricLabellabelCommandParameterInfo); // Populate commands - CommandInfo operationalCredentialsupdateFabricLabelCommandInfo = - new CommandInfo( + InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .updateFabricLabel( @@ -7075,8 +7298,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedNOCResponseCallback(), operationalCredentialsupdateFabricLabelCommandParams); - operationalCredentialsClusterCommandInfoMap.put( - "updateFabricLabel", operationalCredentialsupdateFabricLabelCommandInfo); + operationalCredentialsClusterInteractionInfoMap.put( + "updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); Map operationalCredentialsupdateNOCCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = @@ -7090,8 +7313,8 @@ public Map getCommandMap(Map clusterMa "ICACValue", operationalCredentialsupdateNOCICACValueCommandParameterInfo); // Populate commands - CommandInfo operationalCredentialsupdateNOCCommandInfo = - new CommandInfo( + InteractionInfo operationalCredentialsupdateNOCInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .updateNOC( @@ -7101,47 +7324,23 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedNOCResponseCallback(), operationalCredentialsupdateNOCCommandParams); - operationalCredentialsClusterCommandInfoMap.put( - "updateNOC", operationalCredentialsupdateNOCCommandInfo); - // Populate cluster - ClusterInfo operationalCredentialsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), - operationalCredentialsClusterCommandInfoMap); - clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); - Map powerSourceClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo powerSourceClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), - powerSourceClusterCommandInfoMap); - clusterMap.put("powerSource", powerSourceClusterInfo); - Map pressureMeasurementClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo pressureMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), - pressureMeasurementClusterCommandInfoMap); - clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); - Map pumpConfigurationAndControlClusterCommandInfoMap = + operationalCredentialsClusterInteractionInfoMap.put( + "updateNOC", operationalCredentialsupdateNOCInteractionInfo); + commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); + Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); + Map pressureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo pumpConfigurationAndControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), - pumpConfigurationAndControlClusterCommandInfoMap); - clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); - Map relativeHumidityMeasurementClusterCommandInfoMap = + commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); + Map pumpConfigurationAndControlClusterInteractionInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo relativeHumidityMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), - relativeHumidityMeasurementClusterCommandInfoMap); - clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); - Map scenesClusterCommandInfoMap = new LinkedHashMap<>(); + commandMap.put( + "pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); + Map relativeHumidityMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); + Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); Map scenesaddSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = @@ -7174,8 +7373,8 @@ public Map getCommandMap(Map clusterMa scenesaddSceneCommandParams.put("value", scenesaddScenevalueCommandParameterInfo); // Populate commands - CommandInfo scenesaddSceneCommandInfo = - new CommandInfo( + InteractionInfo scenesaddSceneInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .addScene( @@ -7190,7 +7389,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedAddSceneResponseCallback(), scenesaddSceneCommandParams); - scenesClusterCommandInfoMap.put("addScene", scenesaddSceneCommandInfo); + scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); Map scenesgetSceneMembershipCommandParams = new LinkedHashMap(); CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = @@ -7199,8 +7398,8 @@ public Map getCommandMap(Map clusterMa "groupId", scenesgetSceneMembershipgroupIdCommandParameterInfo); // Populate commands - CommandInfo scenesgetSceneMembershipCommandInfo = - new CommandInfo( + InteractionInfo scenesgetSceneMembershipInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .getSceneMembership( @@ -7209,7 +7408,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedGetSceneMembershipResponseCallback(), scenesgetSceneMembershipCommandParams); - scenesClusterCommandInfoMap.put("getSceneMembership", scenesgetSceneMembershipCommandInfo); + scenesClusterInteractionInfoMap.put( + "getSceneMembership", scenesgetSceneMembershipInteractionInfo); Map scenesrecallSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = @@ -7226,8 +7426,8 @@ public Map getCommandMap(Map clusterMa "transitionTime", scenesrecallScenetransitionTimeCommandParameterInfo); // Populate commands - CommandInfo scenesrecallSceneCommandInfo = - new CommandInfo( + InteractionInfo scenesrecallSceneInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .recallScene( @@ -7238,7 +7438,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), scenesrecallSceneCommandParams); - scenesClusterCommandInfoMap.put("recallScene", scenesrecallSceneCommandInfo); + scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); Map scenesremoveAllScenesCommandParams = new LinkedHashMap(); CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = @@ -7247,8 +7447,8 @@ public Map getCommandMap(Map clusterMa "groupId", scenesremoveAllScenesgroupIdCommandParameterInfo); // Populate commands - CommandInfo scenesremoveAllScenesCommandInfo = - new CommandInfo( + InteractionInfo scenesremoveAllScenesInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .removeAllScenes( @@ -7257,7 +7457,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedRemoveAllScenesResponseCallback(), scenesremoveAllScenesCommandParams); - scenesClusterCommandInfoMap.put("removeAllScenes", scenesremoveAllScenesCommandInfo); + scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); Map scenesremoveSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = @@ -7269,8 +7469,8 @@ public Map getCommandMap(Map clusterMa scenesremoveSceneCommandParams.put("sceneId", scenesremoveScenesceneIdCommandParameterInfo); // Populate commands - CommandInfo scenesremoveSceneCommandInfo = - new CommandInfo( + InteractionInfo scenesremoveSceneInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .removeScene( @@ -7280,7 +7480,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedRemoveSceneResponseCallback(), scenesremoveSceneCommandParams); - scenesClusterCommandInfoMap.put("removeScene", scenesremoveSceneCommandInfo); + scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); Map scenesstoreSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = @@ -7292,8 +7492,8 @@ public Map getCommandMap(Map clusterMa scenesstoreSceneCommandParams.put("sceneId", scenesstoreScenesceneIdCommandParameterInfo); // Populate commands - CommandInfo scenesstoreSceneCommandInfo = - new CommandInfo( + InteractionInfo scenesstoreSceneInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .storeScene( @@ -7303,7 +7503,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedStoreSceneResponseCallback(), scenesstoreSceneCommandParams); - scenesClusterCommandInfoMap.put("storeScene", scenesstoreSceneCommandInfo); + scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); Map scenesviewSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = @@ -7315,8 +7515,8 @@ public Map getCommandMap(Map clusterMa scenesviewSceneCommandParams.put("sceneId", scenesviewScenesceneIdCommandParameterInfo); // Populate commands - CommandInfo scenesviewSceneCommandInfo = - new CommandInfo( + InteractionInfo scenesviewSceneInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .viewScene( @@ -7326,41 +7526,27 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedViewSceneResponseCallback(), scenesviewSceneCommandParams); - scenesClusterCommandInfoMap.put("viewScene", scenesviewSceneCommandInfo); - // Populate cluster - ClusterInfo scenesClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), - scenesClusterCommandInfoMap); - clusterMap.put("scenes", scenesClusterInfo); - Map softwareDiagnosticsClusterCommandInfoMap = new LinkedHashMap<>(); + scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); + commandMap.put("scenes", scenesClusterInteractionInfoMap); + Map softwareDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); Map softwareDiagnosticsresetWatermarksCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo softwareDiagnosticsresetWatermarksCommandInfo = - new CommandInfo( + InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SoftwareDiagnosticsCluster) cluster) .resetWatermarks((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), softwareDiagnosticsresetWatermarksCommandParams); - softwareDiagnosticsClusterCommandInfoMap.put( - "resetWatermarks", softwareDiagnosticsresetWatermarksCommandInfo); - // Populate cluster - ClusterInfo softwareDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), - softwareDiagnosticsClusterCommandInfoMap); - clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); - Map switchClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo switchClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), - switchClusterCommandInfoMap); - clusterMap.put("switch", switchClusterInfo); - Map tvChannelClusterCommandInfoMap = new LinkedHashMap<>(); + softwareDiagnosticsClusterInteractionInfoMap.put( + "resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); + commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); + Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("switch", switchClusterInteractionInfoMap); + Map tvChannelClusterInteractionInfoMap = new LinkedHashMap<>(); Map tvChannelchangeChannelCommandParams = new LinkedHashMap(); CommandParameterInfo tvChannelchangeChannelmatchCommandParameterInfo = @@ -7369,8 +7555,8 @@ public Map getCommandMap(Map clusterMa "match", tvChannelchangeChannelmatchCommandParameterInfo); // Populate commands - CommandInfo tvChannelchangeChannelCommandInfo = - new CommandInfo( + InteractionInfo tvChannelchangeChannelInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TvChannelCluster) cluster) .changeChannel( @@ -7379,7 +7565,7 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedChangeChannelResponseCallback(), tvChannelchangeChannelCommandParams); - tvChannelClusterCommandInfoMap.put("changeChannel", tvChannelchangeChannelCommandInfo); + tvChannelClusterInteractionInfoMap.put("changeChannel", tvChannelchangeChannelInteractionInfo); Map tvChannelchangeChannelByNumberCommandParams = new LinkedHashMap(); CommandParameterInfo tvChannelchangeChannelByNumbermajorNumberCommandParameterInfo = @@ -7393,8 +7579,8 @@ public Map getCommandMap(Map clusterMa "minorNumber", tvChannelchangeChannelByNumberminorNumberCommandParameterInfo); // Populate commands - CommandInfo tvChannelchangeChannelByNumberCommandInfo = - new CommandInfo( + InteractionInfo tvChannelchangeChannelByNumberInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TvChannelCluster) cluster) .changeChannelByNumber( @@ -7404,8 +7590,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), tvChannelchangeChannelByNumberCommandParams); - tvChannelClusterCommandInfoMap.put( - "changeChannelByNumber", tvChannelchangeChannelByNumberCommandInfo); + tvChannelClusterInteractionInfoMap.put( + "changeChannelByNumber", tvChannelchangeChannelByNumberInteractionInfo); Map tvChannelskipChannelCommandParams = new LinkedHashMap(); CommandParameterInfo tvChannelskipChannelcountCommandParameterInfo = @@ -7413,8 +7599,8 @@ public Map getCommandMap(Map clusterMa tvChannelskipChannelCommandParams.put("count", tvChannelskipChannelcountCommandParameterInfo); // Populate commands - CommandInfo tvChannelskipChannelCommandInfo = - new CommandInfo( + InteractionInfo tvChannelskipChannelInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TvChannelCluster) cluster) .skipChannel( @@ -7422,14 +7608,9 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), tvChannelskipChannelCommandParams); - tvChannelClusterCommandInfoMap.put("skipChannel", tvChannelskipChannelCommandInfo); - // Populate cluster - ClusterInfo tvChannelClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TvChannelCluster(ptr, endpointId), - tvChannelClusterCommandInfoMap); - clusterMap.put("tvChannel", tvChannelClusterInfo); - Map targetNavigatorClusterCommandInfoMap = new LinkedHashMap<>(); + tvChannelClusterInteractionInfoMap.put("skipChannel", tvChannelskipChannelInteractionInfo); + commandMap.put("tvChannel", tvChannelClusterInteractionInfoMap); + Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); Map targetNavigatornavigateTargetCommandParams = new LinkedHashMap(); CommandParameterInfo targetNavigatornavigateTargettargetCommandParameterInfo = @@ -7443,8 +7624,8 @@ public Map getCommandMap(Map clusterMa "data", targetNavigatornavigateTargetdataCommandParameterInfo); // Populate commands - CommandInfo targetNavigatornavigateTargetCommandInfo = - new CommandInfo( + InteractionInfo targetNavigatornavigateTargetInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TargetNavigatorCluster) cluster) .navigateTarget( @@ -7454,33 +7635,24 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedNavigateTargetResponseCallback(), targetNavigatornavigateTargetCommandParams); - targetNavigatorClusterCommandInfoMap.put( - "navigateTarget", targetNavigatornavigateTargetCommandInfo); - // Populate cluster - ClusterInfo targetNavigatorClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), - targetNavigatorClusterCommandInfoMap); - clusterMap.put("targetNavigator", targetNavigatorClusterInfo); - Map temperatureMeasurementClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo temperatureMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), - temperatureMeasurementClusterCommandInfoMap); - clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); - Map testClusterClusterCommandInfoMap = new LinkedHashMap<>(); + targetNavigatorClusterInteractionInfoMap.put( + "navigateTarget", targetNavigatornavigateTargetInteractionInfo); + commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); + Map temperatureMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); + Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); Map testClustertestCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo testClustertestCommandInfo = - new CommandInfo( + InteractionInfo testClustertestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster).test((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), testClustertestCommandParams); - testClusterClusterCommandInfoMap.put("test", testClustertestCommandInfo); + testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); Map testClustertestAddArgumentsCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = @@ -7494,8 +7666,8 @@ public Map getCommandMap(Map clusterMa "arg2", testClustertestAddArgumentsarg2CommandParameterInfo); // Populate commands - CommandInfo testClustertestAddArgumentsCommandInfo = - new CommandInfo( + InteractionInfo testClustertestAddArgumentsInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testAddArguments( @@ -7505,8 +7677,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedTestAddArgumentsResponseCallback(), testClustertestAddArgumentsCommandParams); - testClusterClusterCommandInfoMap.put( - "testAddArguments", testClustertestAddArgumentsCommandInfo); + testClusterClusterInteractionInfoMap.put( + "testAddArguments", testClustertestAddArgumentsInteractionInfo); Map testClustertestEnumsRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = @@ -7520,8 +7692,8 @@ public Map getCommandMap(Map clusterMa "arg2", testClustertestEnumsRequestarg2CommandParameterInfo); // Populate commands - CommandInfo testClustertestEnumsRequestCommandInfo = - new CommandInfo( + InteractionInfo testClustertestEnumsRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testEnumsRequest( @@ -7531,8 +7703,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedTestEnumsResponseCallback(), testClustertestEnumsRequestCommandParams); - testClusterClusterCommandInfoMap.put( - "testEnumsRequest", testClustertestEnumsRequestCommandInfo); + testClusterClusterInteractionInfoMap.put( + "testEnumsRequest", testClustertestEnumsRequestInteractionInfo); Map testClustertestListInt8UArgumentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = @@ -7541,8 +7713,8 @@ public Map getCommandMap(Map clusterMa "arg1", testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); // Populate commands - CommandInfo testClustertestListInt8UArgumentRequestCommandInfo = - new CommandInfo( + InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testListInt8UArgumentRequest( @@ -7551,8 +7723,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedBooleanResponseCallback(), testClustertestListInt8UArgumentRequestCommandParams); - testClusterClusterCommandInfoMap.put( - "testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestCommandInfo); + testClusterClusterInteractionInfoMap.put( + "testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); Map testClustertestListInt8UReverseRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = @@ -7561,8 +7733,8 @@ public Map getCommandMap(Map clusterMa "arg1", testClustertestListInt8UReverseRequestarg1CommandParameterInfo); // Populate commands - CommandInfo testClustertestListInt8UReverseRequestCommandInfo = - new CommandInfo( + InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testListInt8UReverseRequest( @@ -7572,8 +7744,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedTestListInt8UReverseResponseCallback(), testClustertestListInt8UReverseRequestCommandParams); - testClusterClusterCommandInfoMap.put( - "testListInt8UReverseRequest", testClustertestListInt8UReverseRequestCommandInfo); + testClusterClusterInteractionInfoMap.put( + "testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); Map testClustertestListStructArgumentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestListStructArgumentRequestaCommandParameterInfo = @@ -7607,8 +7779,8 @@ public Map getCommandMap(Map clusterMa "f", testClustertestListStructArgumentRequestfCommandParameterInfo); // Populate commands - CommandInfo testClustertestListStructArgumentRequestCommandInfo = - new CommandInfo( + InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testListStructArgumentRequest( @@ -7622,20 +7794,21 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedBooleanResponseCallback(), testClustertestListStructArgumentRequestCommandParams); - testClusterClusterCommandInfoMap.put( - "testListStructArgumentRequest", testClustertestListStructArgumentRequestCommandInfo); + testClusterClusterInteractionInfoMap.put( + "testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); Map testClustertestNotHandledCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo testClustertestNotHandledCommandInfo = - new CommandInfo( + InteractionInfo testClustertestNotHandledInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testNotHandled((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), testClustertestNotHandledCommandParams); - testClusterClusterCommandInfoMap.put("testNotHandled", testClustertestNotHandledCommandInfo); + testClusterClusterInteractionInfoMap.put( + "testNotHandled", testClustertestNotHandledInteractionInfo); Map testClustertestNullableOptionalRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = @@ -7644,8 +7817,8 @@ public Map getCommandMap(Map clusterMa "arg1", testClustertestNullableOptionalRequestarg1CommandParameterInfo); // Populate commands - CommandInfo testClustertestNullableOptionalRequestCommandInfo = - new CommandInfo( + InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testNullableOptionalRequest( @@ -7655,13 +7828,13 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedTestNullableOptionalResponseCallback(), testClustertestNullableOptionalRequestCommandParams); - testClusterClusterCommandInfoMap.put( - "testNullableOptionalRequest", testClustertestNullableOptionalRequestCommandInfo); + testClusterClusterInteractionInfoMap.put( + "testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); Map testClustertestSpecificCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo testClustertestSpecificCommandInfo = - new CommandInfo( + InteractionInfo testClustertestSpecificInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testSpecific( @@ -7669,7 +7842,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedTestSpecificResponseCallback(), testClustertestSpecificCommandParams); - testClusterClusterCommandInfoMap.put("testSpecific", testClustertestSpecificCommandInfo); + testClusterClusterInteractionInfoMap.put( + "testSpecific", testClustertestSpecificInteractionInfo); Map testClustertestStructArgumentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestStructArgumentRequestaCommandParameterInfo = @@ -7703,8 +7877,8 @@ public Map getCommandMap(Map clusterMa "f", testClustertestStructArgumentRequestfCommandParameterInfo); // Populate commands - CommandInfo testClustertestStructArgumentRequestCommandInfo = - new CommandInfo( + InteractionInfo testClustertestStructArgumentRequestInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testStructArgumentRequest( @@ -7718,54 +7892,49 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedBooleanResponseCallback(), testClustertestStructArgumentRequestCommandParams); - testClusterClusterCommandInfoMap.put( - "testStructArgumentRequest", testClustertestStructArgumentRequestCommandInfo); + testClusterClusterInteractionInfoMap.put( + "testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); Map testClustertestUnknownCommandCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo testClustertestUnknownCommandCommandInfo = - new CommandInfo( + InteractionInfo testClustertestUnknownCommandInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testUnknownCommand((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), testClustertestUnknownCommandCommandParams); - testClusterClusterCommandInfoMap.put( - "testUnknownCommand", testClustertestUnknownCommandCommandInfo); - // Populate cluster - ClusterInfo testClusterClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), - testClusterClusterCommandInfoMap); - clusterMap.put("testCluster", testClusterClusterInfo); - Map thermostatClusterCommandInfoMap = new LinkedHashMap<>(); + testClusterClusterInteractionInfoMap.put( + "testUnknownCommand", testClustertestUnknownCommandInteractionInfo); + commandMap.put("testCluster", testClusterClusterInteractionInfoMap); + Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); Map thermostatclearWeeklyScheduleCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo thermostatclearWeeklyScheduleCommandInfo = - new CommandInfo( + InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .clearWeeklySchedule((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), thermostatclearWeeklyScheduleCommandParams); - thermostatClusterCommandInfoMap.put( - "clearWeeklySchedule", thermostatclearWeeklyScheduleCommandInfo); + thermostatClusterInteractionInfoMap.put( + "clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); Map thermostatgetRelayStatusLogCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo thermostatgetRelayStatusLogCommandInfo = - new CommandInfo( + InteractionInfo thermostatgetRelayStatusLogInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .getRelayStatusLog((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), thermostatgetRelayStatusLogCommandParams); - thermostatClusterCommandInfoMap.put( - "getRelayStatusLog", thermostatgetRelayStatusLogCommandInfo); + thermostatClusterInteractionInfoMap.put( + "getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); Map thermostatgetWeeklyScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = @@ -7779,8 +7948,8 @@ public Map getCommandMap(Map clusterMa "modeToReturn", thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); // Populate commands - CommandInfo thermostatgetWeeklyScheduleCommandInfo = - new CommandInfo( + InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .getWeeklySchedule( @@ -7790,8 +7959,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), thermostatgetWeeklyScheduleCommandParams); - thermostatClusterCommandInfoMap.put( - "getWeeklySchedule", thermostatgetWeeklyScheduleCommandInfo); + thermostatClusterInteractionInfoMap.put( + "getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); Map thermostatsetWeeklyScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo @@ -7818,8 +7987,8 @@ public Map getCommandMap(Map clusterMa "payload", thermostatsetWeeklySchedulepayloadCommandParameterInfo); // Populate commands - CommandInfo thermostatsetWeeklyScheduleCommandInfo = - new CommandInfo( + InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .setWeeklySchedule( @@ -7831,8 +8000,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), thermostatsetWeeklyScheduleCommandParams); - thermostatClusterCommandInfoMap.put( - "setWeeklySchedule", thermostatsetWeeklyScheduleCommandInfo); + thermostatClusterInteractionInfoMap.put( + "setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); Map thermostatsetpointRaiseLowerCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = @@ -7846,8 +8015,8 @@ public Map getCommandMap(Map clusterMa "amount", thermostatsetpointRaiseLoweramountCommandParameterInfo); // Populate commands - CommandInfo thermostatsetpointRaiseLowerCommandInfo = - new CommandInfo( + InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .setpointRaiseLower( @@ -7857,84 +8026,62 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), thermostatsetpointRaiseLowerCommandParams); - thermostatClusterCommandInfoMap.put( - "setpointRaiseLower", thermostatsetpointRaiseLowerCommandInfo); - // Populate cluster - ClusterInfo thermostatClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), - thermostatClusterCommandInfoMap); - clusterMap.put("thermostat", thermostatClusterInfo); - Map thermostatUserInterfaceConfigurationClusterCommandInfoMap = + thermostatClusterInteractionInfoMap.put( + "setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); + commandMap.put("thermostat", thermostatClusterInteractionInfoMap); + Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "thermostatUserInterfaceConfiguration", + thermostatUserInterfaceConfigurationClusterInteractionInfoMap); + Map threadNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), - thermostatUserInterfaceConfigurationClusterCommandInfoMap); - clusterMap.put( - "thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); - Map threadNetworkDiagnosticsClusterCommandInfoMap = new LinkedHashMap<>(); Map threadNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo threadNetworkDiagnosticsresetCountsCommandInfo = - new CommandInfo( + InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), threadNetworkDiagnosticsresetCountsCommandParams); - threadNetworkDiagnosticsClusterCommandInfoMap.put( - "resetCounts", threadNetworkDiagnosticsresetCountsCommandInfo); - // Populate cluster - ClusterInfo threadNetworkDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), - threadNetworkDiagnosticsClusterCommandInfoMap); - clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); - Map wakeOnLanClusterCommandInfoMap = new LinkedHashMap<>(); - // Populate cluster - ClusterInfo wakeOnLanClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), - wakeOnLanClusterCommandInfoMap); - clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); - Map wiFiNetworkDiagnosticsClusterCommandInfoMap = new LinkedHashMap<>(); + threadNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); + Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); + Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); Map wiFiNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo wiFiNetworkDiagnosticsresetCountsCommandInfo = - new CommandInfo( + InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), wiFiNetworkDiagnosticsresetCountsCommandParams); - wiFiNetworkDiagnosticsClusterCommandInfoMap.put( - "resetCounts", wiFiNetworkDiagnosticsresetCountsCommandInfo); - // Populate cluster - ClusterInfo wiFiNetworkDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), - wiFiNetworkDiagnosticsClusterCommandInfoMap); - clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); - Map windowCoveringClusterCommandInfoMap = new LinkedHashMap<>(); + wiFiNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); + Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); Map windowCoveringdownOrCloseCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo windowCoveringdownOrCloseCommandInfo = - new CommandInfo( + InteractionInfo windowCoveringdownOrCloseInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .downOrClose((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), windowCoveringdownOrCloseCommandParams); - windowCoveringClusterCommandInfoMap.put("downOrClose", windowCoveringdownOrCloseCommandInfo); + windowCoveringClusterInteractionInfoMap.put( + "downOrClose", windowCoveringdownOrCloseInteractionInfo); Map windowCoveringgoToLiftPercentageCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = @@ -7951,8 +8098,8 @@ public Map getCommandMap(Map clusterMa windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); // Populate commands - CommandInfo windowCoveringgoToLiftPercentageCommandInfo = - new CommandInfo( + InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToLiftPercentage( @@ -7962,8 +8109,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), windowCoveringgoToLiftPercentageCommandParams); - windowCoveringClusterCommandInfoMap.put( - "goToLiftPercentage", windowCoveringgoToLiftPercentageCommandInfo); + windowCoveringClusterInteractionInfoMap.put( + "goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); Map windowCoveringgoToLiftValueCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = @@ -7972,8 +8119,8 @@ public Map getCommandMap(Map clusterMa "liftValue", windowCoveringgoToLiftValueliftValueCommandParameterInfo); // Populate commands - CommandInfo windowCoveringgoToLiftValueCommandInfo = - new CommandInfo( + InteractionInfo windowCoveringgoToLiftValueInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToLiftValue( @@ -7982,8 +8129,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), windowCoveringgoToLiftValueCommandParams); - windowCoveringClusterCommandInfoMap.put( - "goToLiftValue", windowCoveringgoToLiftValueCommandInfo); + windowCoveringClusterInteractionInfoMap.put( + "goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); Map windowCoveringgoToTiltPercentageCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = @@ -8000,8 +8147,8 @@ public Map getCommandMap(Map clusterMa windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); // Populate commands - CommandInfo windowCoveringgoToTiltPercentageCommandInfo = - new CommandInfo( + InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToTiltPercentage( @@ -8011,8 +8158,8 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), windowCoveringgoToTiltPercentageCommandParams); - windowCoveringClusterCommandInfoMap.put( - "goToTiltPercentage", windowCoveringgoToTiltPercentageCommandInfo); + windowCoveringClusterInteractionInfoMap.put( + "goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); Map windowCoveringgoToTiltValueCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = @@ -8021,8 +8168,8 @@ public Map getCommandMap(Map clusterMa "tiltValue", windowCoveringgoToTiltValuetiltValueCommandParameterInfo); // Populate commands - CommandInfo windowCoveringgoToTiltValueCommandInfo = - new CommandInfo( + InteractionInfo windowCoveringgoToTiltValueInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToTiltValue( @@ -8031,107 +8178,102 @@ public Map getCommandMap(Map clusterMa }, () -> new DelegatedDefaultClusterCallback(), windowCoveringgoToTiltValueCommandParams); - windowCoveringClusterCommandInfoMap.put( - "goToTiltValue", windowCoveringgoToTiltValueCommandInfo); + windowCoveringClusterInteractionInfoMap.put( + "goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); Map windowCoveringstopMotionCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo windowCoveringstopMotionCommandInfo = - new CommandInfo( + InteractionInfo windowCoveringstopMotionInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .stopMotion((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), windowCoveringstopMotionCommandParams); - windowCoveringClusterCommandInfoMap.put("stopMotion", windowCoveringstopMotionCommandInfo); + windowCoveringClusterInteractionInfoMap.put( + "stopMotion", windowCoveringstopMotionInteractionInfo); Map windowCoveringupOrOpenCommandParams = new LinkedHashMap(); // Populate commands - CommandInfo windowCoveringupOrOpenCommandInfo = - new CommandInfo( + InteractionInfo windowCoveringupOrOpenInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .upOrOpen((DefaultClusterCallback) callback); }, () -> new DelegatedDefaultClusterCallback(), windowCoveringupOrOpenCommandParams); - windowCoveringClusterCommandInfoMap.put("upOrOpen", windowCoveringupOrOpenCommandInfo); - // Populate cluster - ClusterInfo windowCoveringClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), - windowCoveringClusterCommandInfoMap); - clusterMap.put("windowCovering", windowCoveringClusterInfo); - return clusterMap; + windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); + commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); + return commandMap; } - public Map getReadAttributeMap(Map clusterMap) { - Map readAccountLoginCommandInfo = new LinkedHashMap<>(); + public Map> getReadAttributeMap() { + Map> readAttributeMap = new HashMap<>(); + Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); // read attribute Map readAccountLoginClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readAccountLoginClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AccountLoginCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readAccountLoginClusterRevisionCommandParams); - readAccountLoginCommandInfo.put( - "readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("accountLogin").combineCommands(readAccountLoginCommandInfo); - Map readAdministratorCommissioningCommandInfo = new LinkedHashMap<>(); + readAccountLoginInteractionInfo.put( + "readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); + Map readAdministratorCommissioningInteractionInfo = + new LinkedHashMap<>(); // read attribute Map readAdministratorCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readAdministratorCommissioningClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readAdministratorCommissioningClusterRevisionCommandParams); - readAdministratorCommissioningCommandInfo.put( + readAdministratorCommissioningInteractionInfo.put( "readClusterRevisionAttribute", - readAdministratorCommissioningClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap - .get("administratorCommissioning") - .combineCommands(readAdministratorCommissioningCommandInfo); - Map readApplicationBasicCommandInfo = new LinkedHashMap<>(); + readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "administratorCommissioning", readAdministratorCommissioningInteractionInfo); + Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); // read attribute Map readApplicationBasicVendorNameCommandParams = new LinkedHashMap(); - CommandInfo readApplicationBasicVendorNameAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readApplicationBasicVendorNameCommandParams); - readApplicationBasicCommandInfo.put( - "readVendorNameAttribute", readApplicationBasicVendorNameAttributeCommandInfo); + readApplicationBasicInteractionInfo.put( + "readVendorNameAttribute", readApplicationBasicVendorNameAttributeInteractionInfo); Map readApplicationBasicVendorIdCommandParams = new LinkedHashMap(); - CommandInfo readApplicationBasicVendorIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationBasicVendorIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) .readVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readApplicationBasicVendorIdCommandParams); - readApplicationBasicCommandInfo.put( - "readVendorIdAttribute", readApplicationBasicVendorIdAttributeCommandInfo); + readApplicationBasicInteractionInfo.put( + "readVendorIdAttribute", readApplicationBasicVendorIdAttributeInteractionInfo); Map readApplicationBasicApplicationNameCommandParams = new LinkedHashMap(); - CommandInfo readApplicationBasicApplicationNameAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) .readApplicationNameAttribute( @@ -8139,77 +8281,79 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readApplicationBasicApplicationNameCommandParams); - readApplicationBasicCommandInfo.put( - "readApplicationNameAttribute", readApplicationBasicApplicationNameAttributeCommandInfo); + readApplicationBasicInteractionInfo.put( + "readApplicationNameAttribute", + readApplicationBasicApplicationNameAttributeInteractionInfo); Map readApplicationBasicProductIdCommandParams = new LinkedHashMap(); - CommandInfo readApplicationBasicProductIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationBasicProductIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) .readProductIdAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readApplicationBasicProductIdCommandParams); - readApplicationBasicCommandInfo.put( - "readProductIdAttribute", readApplicationBasicProductIdAttributeCommandInfo); + readApplicationBasicInteractionInfo.put( + "readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); Map readApplicationBasicApplicationIdCommandParams = new LinkedHashMap(); - CommandInfo readApplicationBasicApplicationIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationBasicApplicationIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) .readApplicationIdAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readApplicationBasicApplicationIdCommandParams); - readApplicationBasicCommandInfo.put( - "readApplicationIdAttribute", readApplicationBasicApplicationIdAttributeCommandInfo); + readApplicationBasicInteractionInfo.put( + "readApplicationIdAttribute", readApplicationBasicApplicationIdAttributeInteractionInfo); Map readApplicationBasicCatalogVendorIdCommandParams = new LinkedHashMap(); - CommandInfo readApplicationBasicCatalogVendorIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationBasicCatalogVendorIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) .readCatalogVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readApplicationBasicCatalogVendorIdCommandParams); - readApplicationBasicCommandInfo.put( - "readCatalogVendorIdAttribute", readApplicationBasicCatalogVendorIdAttributeCommandInfo); + readApplicationBasicInteractionInfo.put( + "readCatalogVendorIdAttribute", + readApplicationBasicCatalogVendorIdAttributeInteractionInfo); Map readApplicationBasicApplicationStatusCommandParams = new LinkedHashMap(); - CommandInfo readApplicationBasicApplicationStatusAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) .readApplicationStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readApplicationBasicApplicationStatusCommandParams); - readApplicationBasicCommandInfo.put( + readApplicationBasicInteractionInfo.put( "readApplicationStatusAttribute", - readApplicationBasicApplicationStatusAttributeCommandInfo); + readApplicationBasicApplicationStatusAttributeInteractionInfo); Map readApplicationBasicClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readApplicationBasicClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readApplicationBasicClusterRevisionCommandParams); - readApplicationBasicCommandInfo.put( - "readClusterRevisionAttribute", readApplicationBasicClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("applicationBasic").combineCommands(readApplicationBasicCommandInfo); - Map readApplicationLauncherCommandInfo = new LinkedHashMap<>(); + readApplicationBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readApplicationBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); + Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); // read attribute Map readApplicationLauncherApplicationLauncherListCommandParams = new LinkedHashMap(); - CommandInfo readApplicationLauncherApplicationLauncherListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationLauncherCluster) cluster) .readApplicationLauncherListAttribute( @@ -8219,53 +8363,54 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedApplicationLauncherListAttributeCallback(), readApplicationLauncherApplicationLauncherListCommandParams); - readApplicationLauncherCommandInfo.put( + readApplicationLauncherInteractionInfo.put( "readApplicationLauncherListAttribute", - readApplicationLauncherApplicationLauncherListAttributeCommandInfo); + readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); Map readApplicationLauncherCatalogVendorIdCommandParams = new LinkedHashMap(); - CommandInfo readApplicationLauncherCatalogVendorIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationLauncherCatalogVendorIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationLauncherCluster) cluster) .readCatalogVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readApplicationLauncherCatalogVendorIdCommandParams); - readApplicationLauncherCommandInfo.put( - "readCatalogVendorIdAttribute", readApplicationLauncherCatalogVendorIdAttributeCommandInfo); + readApplicationLauncherInteractionInfo.put( + "readCatalogVendorIdAttribute", + readApplicationLauncherCatalogVendorIdAttributeInteractionInfo); Map readApplicationLauncherApplicationIdCommandParams = new LinkedHashMap(); - CommandInfo readApplicationLauncherApplicationIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationLauncherApplicationIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationLauncherCluster) cluster) .readApplicationIdAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readApplicationLauncherApplicationIdCommandParams); - readApplicationLauncherCommandInfo.put( - "readApplicationIdAttribute", readApplicationLauncherApplicationIdAttributeCommandInfo); + readApplicationLauncherInteractionInfo.put( + "readApplicationIdAttribute", readApplicationLauncherApplicationIdAttributeInteractionInfo); Map readApplicationLauncherClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readApplicationLauncherClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationLauncherCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readApplicationLauncherClusterRevisionCommandParams); - readApplicationLauncherCommandInfo.put( - "readClusterRevisionAttribute", readApplicationLauncherClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("applicationLauncher").combineCommands(readApplicationLauncherCommandInfo); - Map readAudioOutputCommandInfo = new LinkedHashMap<>(); + readApplicationLauncherInteractionInfo.put( + "readClusterRevisionAttribute", + readApplicationLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); + Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); // read attribute Map readAudioOutputAudioOutputListCommandParams = new LinkedHashMap(); - CommandInfo readAudioOutputAudioOutputListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) .readAudioOutputListAttribute( @@ -8273,12 +8418,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedAudioOutputListAttributeCallback(), readAudioOutputAudioOutputListCommandParams); - readAudioOutputCommandInfo.put( - "readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeCommandInfo); + readAudioOutputInteractionInfo.put( + "readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); Map readAudioOutputCurrentAudioOutputCommandParams = new LinkedHashMap(); - CommandInfo readAudioOutputCurrentAudioOutputAttributeCommandInfo = - new CommandInfo( + InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) .readCurrentAudioOutputAttribute( @@ -8286,28 +8431,28 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readAudioOutputCurrentAudioOutputCommandParams); - readAudioOutputCommandInfo.put( - "readCurrentAudioOutputAttribute", readAudioOutputCurrentAudioOutputAttributeCommandInfo); + readAudioOutputInteractionInfo.put( + "readCurrentAudioOutputAttribute", + readAudioOutputCurrentAudioOutputAttributeInteractionInfo); Map readAudioOutputClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readAudioOutputClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readAudioOutputClusterRevisionCommandParams); - readAudioOutputCommandInfo.put( - "readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("audioOutput").combineCommands(readAudioOutputCommandInfo); - Map readBarrierControlCommandInfo = new LinkedHashMap<>(); + readAudioOutputInteractionInfo.put( + "readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); + Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); // read attribute Map readBarrierControlBarrierMovingStateCommandParams = new LinkedHashMap(); - CommandInfo readBarrierControlBarrierMovingStateAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .readBarrierMovingStateAttribute( @@ -8315,13 +8460,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readBarrierControlBarrierMovingStateCommandParams); - readBarrierControlCommandInfo.put( + readBarrierControlInteractionInfo.put( "readBarrierMovingStateAttribute", - readBarrierControlBarrierMovingStateAttributeCommandInfo); + readBarrierControlBarrierMovingStateAttributeInteractionInfo); Map readBarrierControlBarrierSafetyStatusCommandParams = new LinkedHashMap(); - CommandInfo readBarrierControlBarrierSafetyStatusAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBarrierControlBarrierSafetyStatusAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .readBarrierSafetyStatusAttribute( @@ -8329,13 +8474,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readBarrierControlBarrierSafetyStatusCommandParams); - readBarrierControlCommandInfo.put( + readBarrierControlInteractionInfo.put( "readBarrierSafetyStatusAttribute", - readBarrierControlBarrierSafetyStatusAttributeCommandInfo); + readBarrierControlBarrierSafetyStatusAttributeInteractionInfo); Map readBarrierControlBarrierCapabilitiesCommandParams = new LinkedHashMap(); - CommandInfo readBarrierControlBarrierCapabilitiesAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBarrierControlBarrierCapabilitiesAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .readBarrierCapabilitiesAttribute( @@ -8343,41 +8488,40 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readBarrierControlBarrierCapabilitiesCommandParams); - readBarrierControlCommandInfo.put( + readBarrierControlInteractionInfo.put( "readBarrierCapabilitiesAttribute", - readBarrierControlBarrierCapabilitiesAttributeCommandInfo); + readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); Map readBarrierControlBarrierPositionCommandParams = new LinkedHashMap(); - CommandInfo readBarrierControlBarrierPositionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .readBarrierPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBarrierControlBarrierPositionCommandParams); - readBarrierControlCommandInfo.put( - "readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeCommandInfo); + readBarrierControlInteractionInfo.put( + "readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); Map readBarrierControlClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readBarrierControlClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBarrierControlClusterRevisionCommandParams); - readBarrierControlCommandInfo.put( - "readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("barrierControl").combineCommands(readBarrierControlCommandInfo); - Map readBasicCommandInfo = new LinkedHashMap<>(); + readBarrierControlInteractionInfo.put( + "readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); + Map readBasicInteractionInfo = new LinkedHashMap<>(); // read attribute Map readBasicInteractionModelVersionCommandParams = new LinkedHashMap(); - CommandInfo readBasicInteractionModelVersionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readInteractionModelVersionAttribute( @@ -8385,91 +8529,97 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readBasicInteractionModelVersionCommandParams); - readBasicCommandInfo.put( + readBasicInteractionInfo.put( "readInteractionModelVersionAttribute", - readBasicInteractionModelVersionAttributeCommandInfo); + readBasicInteractionModelVersionAttributeInteractionInfo); Map readBasicVendorNameCommandParams = new LinkedHashMap(); - CommandInfo readBasicVendorNameAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBasicVendorNameCommandParams); - readBasicCommandInfo.put("readVendorNameAttribute", readBasicVendorNameAttributeCommandInfo); + readBasicInteractionInfo.put( + "readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); Map readBasicVendorIDCommandParams = new LinkedHashMap(); - CommandInfo readBasicVendorIDAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicVendorIDAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBasicVendorIDCommandParams); - readBasicCommandInfo.put("readVendorIDAttribute", readBasicVendorIDAttributeCommandInfo); + readBasicInteractionInfo.put( + "readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); Map readBasicProductNameCommandParams = new LinkedHashMap(); - CommandInfo readBasicProductNameAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicProductNameAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBasicProductNameCommandParams); - readBasicCommandInfo.put("readProductNameAttribute", readBasicProductNameAttributeCommandInfo); + readBasicInteractionInfo.put( + "readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); Map readBasicProductIDCommandParams = new LinkedHashMap(); - CommandInfo readBasicProductIDAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicProductIDAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBasicProductIDCommandParams); - readBasicCommandInfo.put("readProductIDAttribute", readBasicProductIDAttributeCommandInfo); + readBasicInteractionInfo.put( + "readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); Map readBasicUserLabelCommandParams = new LinkedHashMap(); - CommandInfo readBasicUserLabelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicUserLabelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readUserLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBasicUserLabelCommandParams); - readBasicCommandInfo.put("readUserLabelAttribute", readBasicUserLabelAttributeCommandInfo); + readBasicInteractionInfo.put( + "readUserLabelAttribute", readBasicUserLabelAttributeInteractionInfo); Map readBasicLocationCommandParams = new LinkedHashMap(); - CommandInfo readBasicLocationAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicLocationAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readLocationAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBasicLocationCommandParams); - readBasicCommandInfo.put("readLocationAttribute", readBasicLocationAttributeCommandInfo); + readBasicInteractionInfo.put( + "readLocationAttribute", readBasicLocationAttributeInteractionInfo); Map readBasicHardwareVersionCommandParams = new LinkedHashMap(); - CommandInfo readBasicHardwareVersionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBasicHardwareVersionCommandParams); - readBasicCommandInfo.put( - "readHardwareVersionAttribute", readBasicHardwareVersionAttributeCommandInfo); + readBasicInteractionInfo.put( + "readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); Map readBasicHardwareVersionStringCommandParams = new LinkedHashMap(); - CommandInfo readBasicHardwareVersionStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readHardwareVersionStringAttribute( @@ -8477,24 +8627,25 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readBasicHardwareVersionStringCommandParams); - readBasicCommandInfo.put( - "readHardwareVersionStringAttribute", readBasicHardwareVersionStringAttributeCommandInfo); + readBasicInteractionInfo.put( + "readHardwareVersionStringAttribute", + readBasicHardwareVersionStringAttributeInteractionInfo); Map readBasicSoftwareVersionCommandParams = new LinkedHashMap(); - CommandInfo readBasicSoftwareVersionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readBasicSoftwareVersionCommandParams); - readBasicCommandInfo.put( - "readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeCommandInfo); + readBasicInteractionInfo.put( + "readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); Map readBasicSoftwareVersionStringCommandParams = new LinkedHashMap(); - CommandInfo readBasicSoftwareVersionStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readSoftwareVersionStringAttribute( @@ -8502,12 +8653,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readBasicSoftwareVersionStringCommandParams); - readBasicCommandInfo.put( - "readSoftwareVersionStringAttribute", readBasicSoftwareVersionStringAttributeCommandInfo); + readBasicInteractionInfo.put( + "readSoftwareVersionStringAttribute", + readBasicSoftwareVersionStringAttributeInteractionInfo); Map readBasicManufacturingDateCommandParams = new LinkedHashMap(); - CommandInfo readBasicManufacturingDateAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readManufacturingDateAttribute( @@ -8515,58 +8667,60 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readBasicManufacturingDateCommandParams); - readBasicCommandInfo.put( - "readManufacturingDateAttribute", readBasicManufacturingDateAttributeCommandInfo); + readBasicInteractionInfo.put( + "readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); Map readBasicPartNumberCommandParams = new LinkedHashMap(); - CommandInfo readBasicPartNumberAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicPartNumberAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBasicPartNumberCommandParams); - readBasicCommandInfo.put("readPartNumberAttribute", readBasicPartNumberAttributeCommandInfo); + readBasicInteractionInfo.put( + "readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); Map readBasicProductURLCommandParams = new LinkedHashMap(); - CommandInfo readBasicProductURLAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicProductURLAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBasicProductURLCommandParams); - readBasicCommandInfo.put("readProductURLAttribute", readBasicProductURLAttributeCommandInfo); + readBasicInteractionInfo.put( + "readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); Map readBasicProductLabelCommandParams = new LinkedHashMap(); - CommandInfo readBasicProductLabelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicProductLabelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBasicProductLabelCommandParams); - readBasicCommandInfo.put( - "readProductLabelAttribute", readBasicProductLabelAttributeCommandInfo); + readBasicInteractionInfo.put( + "readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); Map readBasicSerialNumberCommandParams = new LinkedHashMap(); - CommandInfo readBasicSerialNumberAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicSerialNumberAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBasicSerialNumberCommandParams); - readBasicCommandInfo.put( - "readSerialNumberAttribute", readBasicSerialNumberAttributeCommandInfo); + readBasicInteractionInfo.put( + "readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); Map readBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); - CommandInfo readBasicLocalConfigDisabledAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readLocalConfigDisabledAttribute( @@ -8574,135 +8728,133 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedBooleanAttributeCallback(), readBasicLocalConfigDisabledCommandParams); - readBasicCommandInfo.put( - "readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeCommandInfo); + readBasicInteractionInfo.put( + "readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); Map readBasicReachableCommandParams = new LinkedHashMap(); - CommandInfo readBasicReachableAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicReachableAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readBasicReachableCommandParams); - readBasicCommandInfo.put("readReachableAttribute", readBasicReachableAttributeCommandInfo); + readBasicInteractionInfo.put( + "readReachableAttribute", readBasicReachableAttributeInteractionInfo); Map readBasicClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readBasicClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBasicClusterRevisionCommandParams); - readBasicCommandInfo.put( - "readClusterRevisionAttribute", readBasicClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("basic").combineCommands(readBasicCommandInfo); - Map readBinaryInputBasicCommandInfo = new LinkedHashMap<>(); + readBasicInteractionInfo.put( + "readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("basic", readBasicInteractionInfo); + Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); // read attribute Map readBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); - CommandInfo readBinaryInputBasicOutOfServiceAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BinaryInputBasicCluster) cluster) .readOutOfServiceAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readBinaryInputBasicOutOfServiceCommandParams); - readBinaryInputBasicCommandInfo.put( - "readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeCommandInfo); + readBinaryInputBasicInteractionInfo.put( + "readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); Map readBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); - CommandInfo readBinaryInputBasicPresentValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BinaryInputBasicCluster) cluster) .readPresentValueAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readBinaryInputBasicPresentValueCommandParams); - readBinaryInputBasicCommandInfo.put( - "readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeCommandInfo); + readBinaryInputBasicInteractionInfo.put( + "readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); Map readBinaryInputBasicStatusFlagsCommandParams = new LinkedHashMap(); - CommandInfo readBinaryInputBasicStatusFlagsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BinaryInputBasicCluster) cluster) .readStatusFlagsAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBinaryInputBasicStatusFlagsCommandParams); - readBinaryInputBasicCommandInfo.put( - "readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeCommandInfo); + readBinaryInputBasicInteractionInfo.put( + "readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); Map readBinaryInputBasicClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readBinaryInputBasicClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BinaryInputBasicCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBinaryInputBasicClusterRevisionCommandParams); - readBinaryInputBasicCommandInfo.put( - "readClusterRevisionAttribute", readBinaryInputBasicClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("binaryInputBasic").combineCommands(readBinaryInputBasicCommandInfo); - Map readBindingCommandInfo = new LinkedHashMap<>(); + readBinaryInputBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readBinaryInputBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); + Map readBindingInteractionInfo = new LinkedHashMap<>(); // read attribute Map readBindingClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readBindingClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BindingCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBindingClusterRevisionCommandParams); - readBindingCommandInfo.put( - "readClusterRevisionAttribute", readBindingClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("binding").combineCommands(readBindingCommandInfo); - Map readBooleanStateCommandInfo = new LinkedHashMap<>(); + readBindingInteractionInfo.put( + "readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binding", readBindingInteractionInfo); + Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); // read attribute Map readBooleanStateStateValueCommandParams = new LinkedHashMap(); - CommandInfo readBooleanStateStateValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BooleanStateCluster) cluster) .readStateValueAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readBooleanStateStateValueCommandParams); - readBooleanStateCommandInfo.put( - "readStateValueAttribute", readBooleanStateStateValueAttributeCommandInfo); + readBooleanStateInteractionInfo.put( + "readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); Map readBooleanStateClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readBooleanStateClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BooleanStateCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBooleanStateClusterRevisionCommandParams); - readBooleanStateCommandInfo.put( - "readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("booleanState").combineCommands(readBooleanStateCommandInfo); - Map readBridgedActionsCommandInfo = new LinkedHashMap<>(); + readBooleanStateInteractionInfo.put( + "readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); + Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); // read attribute Map readBridgedActionsActionListCommandParams = new LinkedHashMap(); - CommandInfo readBridgedActionsActionListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .readActionListAttribute( @@ -8710,12 +8862,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedActionListAttributeCallback(), readBridgedActionsActionListCommandParams); - readBridgedActionsCommandInfo.put( - "readActionListAttribute", readBridgedActionsActionListAttributeCommandInfo); + readBridgedActionsInteractionInfo.put( + "readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); Map readBridgedActionsEndpointListCommandParams = new LinkedHashMap(); - CommandInfo readBridgedActionsEndpointListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .readEndpointListAttribute( @@ -8723,100 +8875,100 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedEndpointListAttributeCallback(), readBridgedActionsEndpointListCommandParams); - readBridgedActionsCommandInfo.put( - "readEndpointListAttribute", readBridgedActionsEndpointListAttributeCommandInfo); + readBridgedActionsInteractionInfo.put( + "readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); Map readBridgedActionsSetupUrlCommandParams = new LinkedHashMap(); - CommandInfo readBridgedActionsSetupUrlAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .readSetupUrlAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBridgedActionsSetupUrlCommandParams); - readBridgedActionsCommandInfo.put( - "readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeCommandInfo); + readBridgedActionsInteractionInfo.put( + "readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); Map readBridgedActionsClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readBridgedActionsClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBridgedActionsClusterRevisionCommandParams); - readBridgedActionsCommandInfo.put( - "readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("bridgedActions").combineCommands(readBridgedActionsCommandInfo); - Map readBridgedDeviceBasicCommandInfo = new LinkedHashMap<>(); + readBridgedActionsInteractionInfo.put( + "readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); + Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); // read attribute Map readBridgedDeviceBasicVendorNameCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicVendorNameAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicVendorNameCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readVendorNameAttribute", readBridgedDeviceBasicVendorNameAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readVendorNameAttribute", readBridgedDeviceBasicVendorNameAttributeInteractionInfo); Map readBridgedDeviceBasicVendorIDCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicVendorIDAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicVendorIDAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBridgedDeviceBasicVendorIDCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readVendorIDAttribute", readBridgedDeviceBasicVendorIDAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readVendorIDAttribute", readBridgedDeviceBasicVendorIDAttributeInteractionInfo); Map readBridgedDeviceBasicProductNameCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicProductNameAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicProductNameAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicProductNameCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readProductNameAttribute", readBridgedDeviceBasicProductNameAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readProductNameAttribute", readBridgedDeviceBasicProductNameAttributeInteractionInfo); Map readBridgedDeviceBasicUserLabelCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicUserLabelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicUserLabelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readUserLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicUserLabelCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readUserLabelAttribute", readBridgedDeviceBasicUserLabelAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readUserLabelAttribute", readBridgedDeviceBasicUserLabelAttributeInteractionInfo); Map readBridgedDeviceBasicHardwareVersionCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicHardwareVersionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicHardwareVersionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBridgedDeviceBasicHardwareVersionCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readHardwareVersionAttribute", readBridgedDeviceBasicHardwareVersionAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readHardwareVersionAttribute", + readBridgedDeviceBasicHardwareVersionAttributeInteractionInfo); Map readBridgedDeviceBasicHardwareVersionStringCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicHardwareVersionStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicHardwareVersionStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readHardwareVersionStringAttribute( @@ -8824,25 +8976,26 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicHardwareVersionStringCommandParams); - readBridgedDeviceBasicCommandInfo.put( + readBridgedDeviceBasicInteractionInfo.put( "readHardwareVersionStringAttribute", - readBridgedDeviceBasicHardwareVersionStringAttributeCommandInfo); + readBridgedDeviceBasicHardwareVersionStringAttributeInteractionInfo); Map readBridgedDeviceBasicSoftwareVersionCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicSoftwareVersionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicSoftwareVersionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readBridgedDeviceBasicSoftwareVersionCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readSoftwareVersionAttribute", readBridgedDeviceBasicSoftwareVersionAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readSoftwareVersionAttribute", + readBridgedDeviceBasicSoftwareVersionAttributeInteractionInfo); Map readBridgedDeviceBasicSoftwareVersionStringCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicSoftwareVersionStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicSoftwareVersionStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readSoftwareVersionStringAttribute( @@ -8850,13 +9003,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicSoftwareVersionStringCommandParams); - readBridgedDeviceBasicCommandInfo.put( + readBridgedDeviceBasicInteractionInfo.put( "readSoftwareVersionStringAttribute", - readBridgedDeviceBasicSoftwareVersionStringAttributeCommandInfo); + readBridgedDeviceBasicSoftwareVersionStringAttributeInteractionInfo); Map readBridgedDeviceBasicManufacturingDateCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicManufacturingDateAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicManufacturingDateAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readManufacturingDateAttribute( @@ -8864,161 +9017,163 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicManufacturingDateCommandParams); - readBridgedDeviceBasicCommandInfo.put( + readBridgedDeviceBasicInteractionInfo.put( "readManufacturingDateAttribute", - readBridgedDeviceBasicManufacturingDateAttributeCommandInfo); + readBridgedDeviceBasicManufacturingDateAttributeInteractionInfo); Map readBridgedDeviceBasicPartNumberCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicPartNumberAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicPartNumberAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicPartNumberCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readPartNumberAttribute", readBridgedDeviceBasicPartNumberAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readPartNumberAttribute", readBridgedDeviceBasicPartNumberAttributeInteractionInfo); Map readBridgedDeviceBasicProductURLCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicProductURLAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicProductURLAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicProductURLCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readProductURLAttribute", readBridgedDeviceBasicProductURLAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readProductURLAttribute", readBridgedDeviceBasicProductURLAttributeInteractionInfo); Map readBridgedDeviceBasicProductLabelCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicProductLabelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicProductLabelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicProductLabelCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readProductLabelAttribute", readBridgedDeviceBasicProductLabelAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readProductLabelAttribute", readBridgedDeviceBasicProductLabelAttributeInteractionInfo); Map readBridgedDeviceBasicSerialNumberCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicSerialNumberAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicSerialNumberAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readBridgedDeviceBasicSerialNumberCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readSerialNumberAttribute", readBridgedDeviceBasicSerialNumberAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readSerialNumberAttribute", readBridgedDeviceBasicSerialNumberAttributeInteractionInfo); Map readBridgedDeviceBasicReachableCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicReachableAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicReachableAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readBridgedDeviceBasicReachableCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readReachableAttribute", readBridgedDeviceBasicReachableAttributeCommandInfo); + readBridgedDeviceBasicInteractionInfo.put( + "readReachableAttribute", readBridgedDeviceBasicReachableAttributeInteractionInfo); Map readBridgedDeviceBasicClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readBridgedDeviceBasicClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readBridgedDeviceBasicClusterRevisionCommandParams); - readBridgedDeviceBasicCommandInfo.put( - "readClusterRevisionAttribute", readBridgedDeviceBasicClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("bridgedDeviceBasic").combineCommands(readBridgedDeviceBasicCommandInfo); - Map readColorControlCommandInfo = new LinkedHashMap<>(); + readBridgedDeviceBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); + Map readColorControlInteractionInfo = new LinkedHashMap<>(); // read attribute Map readColorControlCurrentHueCommandParams = new LinkedHashMap(); - CommandInfo readColorControlCurrentHueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readCurrentHueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlCurrentHueCommandParams); - readColorControlCommandInfo.put( - "readCurrentHueAttribute", readColorControlCurrentHueAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readCurrentHueAttribute", readColorControlCurrentHueAttributeInteractionInfo); Map readColorControlCurrentSaturationCommandParams = new LinkedHashMap(); - CommandInfo readColorControlCurrentSaturationAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlCurrentSaturationAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readCurrentSaturationAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlCurrentSaturationCommandParams); - readColorControlCommandInfo.put( - "readCurrentSaturationAttribute", readColorControlCurrentSaturationAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readCurrentSaturationAttribute", + readColorControlCurrentSaturationAttributeInteractionInfo); Map readColorControlRemainingTimeCommandParams = new LinkedHashMap(); - CommandInfo readColorControlRemainingTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlRemainingTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readRemainingTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlRemainingTimeCommandParams); - readColorControlCommandInfo.put( - "readRemainingTimeAttribute", readColorControlRemainingTimeAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readRemainingTimeAttribute", readColorControlRemainingTimeAttributeInteractionInfo); Map readColorControlCurrentXCommandParams = new LinkedHashMap(); - CommandInfo readColorControlCurrentXAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlCurrentXAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readCurrentXAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlCurrentXCommandParams); - readColorControlCommandInfo.put( - "readCurrentXAttribute", readColorControlCurrentXAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readCurrentXAttribute", readColorControlCurrentXAttributeInteractionInfo); Map readColorControlCurrentYCommandParams = new LinkedHashMap(); - CommandInfo readColorControlCurrentYAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlCurrentYAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readCurrentYAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlCurrentYCommandParams); - readColorControlCommandInfo.put( - "readCurrentYAttribute", readColorControlCurrentYAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readCurrentYAttribute", readColorControlCurrentYAttributeInteractionInfo); Map readColorControlDriftCompensationCommandParams = new LinkedHashMap(); - CommandInfo readColorControlDriftCompensationAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlDriftCompensationAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readDriftCompensationAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlDriftCompensationCommandParams); - readColorControlCommandInfo.put( - "readDriftCompensationAttribute", readColorControlDriftCompensationAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readDriftCompensationAttribute", + readColorControlDriftCompensationAttributeInteractionInfo); Map readColorControlCompensationTextCommandParams = new LinkedHashMap(); - CommandInfo readColorControlCompensationTextAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readCompensationTextAttribute( @@ -9026,36 +9181,36 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readColorControlCompensationTextCommandParams); - readColorControlCommandInfo.put( - "readCompensationTextAttribute", readColorControlCompensationTextAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); Map readColorControlColorTemperatureCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorTemperatureAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorTemperatureCommandParams); - readColorControlCommandInfo.put( - "readColorTemperatureAttribute", readColorControlColorTemperatureAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); Map readColorControlColorModeCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorModeCommandParams); - readColorControlCommandInfo.put( - "readColorModeAttribute", readColorControlColorModeAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); Map readColorControlColorControlOptionsCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorControlOptionsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorControlOptionsAttribute( @@ -9063,289 +9218,296 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorControlOptionsCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readColorControlOptionsAttribute", - readColorControlColorControlOptionsAttributeCommandInfo); + readColorControlColorControlOptionsAttributeInteractionInfo); Map readColorControlNumberOfPrimariesCommandParams = new LinkedHashMap(); - CommandInfo readColorControlNumberOfPrimariesAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readNumberOfPrimariesAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlNumberOfPrimariesCommandParams); - readColorControlCommandInfo.put( - "readNumberOfPrimariesAttribute", readColorControlNumberOfPrimariesAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readNumberOfPrimariesAttribute", + readColorControlNumberOfPrimariesAttributeInteractionInfo); Map readColorControlPrimary1XCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary1XAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary1XAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary1XAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary1XCommandParams); - readColorControlCommandInfo.put( - "readPrimary1XAttribute", readColorControlPrimary1XAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary1XAttribute", readColorControlPrimary1XAttributeInteractionInfo); Map readColorControlPrimary1YCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary1YAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary1YAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary1YAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary1YCommandParams); - readColorControlCommandInfo.put( - "readPrimary1YAttribute", readColorControlPrimary1YAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); Map readColorControlPrimary1IntensityCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary1IntensityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary1IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary1IntensityCommandParams); - readColorControlCommandInfo.put( - "readPrimary1IntensityAttribute", readColorControlPrimary1IntensityAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary1IntensityAttribute", + readColorControlPrimary1IntensityAttributeInteractionInfo); Map readColorControlPrimary2XCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary2XAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary2XAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary2XAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary2XCommandParams); - readColorControlCommandInfo.put( - "readPrimary2XAttribute", readColorControlPrimary2XAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary2XAttribute", readColorControlPrimary2XAttributeInteractionInfo); Map readColorControlPrimary2YCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary2YAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary2YAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary2YAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary2YCommandParams); - readColorControlCommandInfo.put( - "readPrimary2YAttribute", readColorControlPrimary2YAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); Map readColorControlPrimary2IntensityCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary2IntensityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary2IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary2IntensityCommandParams); - readColorControlCommandInfo.put( - "readPrimary2IntensityAttribute", readColorControlPrimary2IntensityAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary2IntensityAttribute", + readColorControlPrimary2IntensityAttributeInteractionInfo); Map readColorControlPrimary3XCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary3XAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary3XAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary3XAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary3XCommandParams); - readColorControlCommandInfo.put( - "readPrimary3XAttribute", readColorControlPrimary3XAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary3XAttribute", readColorControlPrimary3XAttributeInteractionInfo); Map readColorControlPrimary3YCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary3YAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary3YAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary3YAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary3YCommandParams); - readColorControlCommandInfo.put( - "readPrimary3YAttribute", readColorControlPrimary3YAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); Map readColorControlPrimary3IntensityCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary3IntensityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary3IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary3IntensityCommandParams); - readColorControlCommandInfo.put( - "readPrimary3IntensityAttribute", readColorControlPrimary3IntensityAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary3IntensityAttribute", + readColorControlPrimary3IntensityAttributeInteractionInfo); Map readColorControlPrimary4XCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary4XAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary4XAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary4XAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary4XCommandParams); - readColorControlCommandInfo.put( - "readPrimary4XAttribute", readColorControlPrimary4XAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary4XAttribute", readColorControlPrimary4XAttributeInteractionInfo); Map readColorControlPrimary4YCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary4YAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary4YAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary4YAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary4YCommandParams); - readColorControlCommandInfo.put( - "readPrimary4YAttribute", readColorControlPrimary4YAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); Map readColorControlPrimary4IntensityCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary4IntensityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary4IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary4IntensityCommandParams); - readColorControlCommandInfo.put( - "readPrimary4IntensityAttribute", readColorControlPrimary4IntensityAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary4IntensityAttribute", + readColorControlPrimary4IntensityAttributeInteractionInfo); Map readColorControlPrimary5XCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary5XAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary5XAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary5XAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary5XCommandParams); - readColorControlCommandInfo.put( - "readPrimary5XAttribute", readColorControlPrimary5XAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary5XAttribute", readColorControlPrimary5XAttributeInteractionInfo); Map readColorControlPrimary5YCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary5YAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary5YAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary5YAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary5YCommandParams); - readColorControlCommandInfo.put( - "readPrimary5YAttribute", readColorControlPrimary5YAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); Map readColorControlPrimary5IntensityCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary5IntensityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary5IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary5IntensityCommandParams); - readColorControlCommandInfo.put( - "readPrimary5IntensityAttribute", readColorControlPrimary5IntensityAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary5IntensityAttribute", + readColorControlPrimary5IntensityAttributeInteractionInfo); Map readColorControlPrimary6XCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary6XAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary6XAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary6XAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary6XCommandParams); - readColorControlCommandInfo.put( - "readPrimary6XAttribute", readColorControlPrimary6XAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary6XAttribute", readColorControlPrimary6XAttributeInteractionInfo); Map readColorControlPrimary6YCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary6YAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary6YAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary6YAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary6YCommandParams); - readColorControlCommandInfo.put( - "readPrimary6YAttribute", readColorControlPrimary6YAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); Map readColorControlPrimary6IntensityCommandParams = new LinkedHashMap(); - CommandInfo readColorControlPrimary6IntensityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readPrimary6IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlPrimary6IntensityCommandParams); - readColorControlCommandInfo.put( - "readPrimary6IntensityAttribute", readColorControlPrimary6IntensityAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readPrimary6IntensityAttribute", + readColorControlPrimary6IntensityAttributeInteractionInfo); Map readColorControlWhitePointXCommandParams = new LinkedHashMap(); - CommandInfo readColorControlWhitePointXAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlWhitePointXAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readWhitePointXAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlWhitePointXCommandParams); - readColorControlCommandInfo.put( - "readWhitePointXAttribute", readColorControlWhitePointXAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readWhitePointXAttribute", readColorControlWhitePointXAttributeInteractionInfo); Map readColorControlWhitePointYCommandParams = new LinkedHashMap(); - CommandInfo readColorControlWhitePointYAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlWhitePointYAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readWhitePointYAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlWhitePointYCommandParams); - readColorControlCommandInfo.put( - "readWhitePointYAttribute", readColorControlWhitePointYAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readWhitePointYAttribute", readColorControlWhitePointYAttributeInteractionInfo); Map readColorControlColorPointRXCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorPointRXAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorPointRXAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorPointRXAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorPointRXCommandParams); - readColorControlCommandInfo.put( - "readColorPointRXAttribute", readColorControlColorPointRXAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorPointRXAttribute", readColorControlColorPointRXAttributeInteractionInfo); Map readColorControlColorPointRYCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorPointRYAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorPointRYAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorPointRYAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorPointRYCommandParams); - readColorControlCommandInfo.put( - "readColorPointRYAttribute", readColorControlColorPointRYAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); Map readColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorPointRIntensityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorPointRIntensityAttribute( @@ -9353,37 +9515,37 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorPointRIntensityCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readColorPointRIntensityAttribute", - readColorControlColorPointRIntensityAttributeCommandInfo); + readColorControlColorPointRIntensityAttributeInteractionInfo); Map readColorControlColorPointGXCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorPointGXAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorPointGXAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorPointGXAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorPointGXCommandParams); - readColorControlCommandInfo.put( - "readColorPointGXAttribute", readColorControlColorPointGXAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorPointGXAttribute", readColorControlColorPointGXAttributeInteractionInfo); Map readColorControlColorPointGYCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorPointGYAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorPointGYAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorPointGYAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorPointGYCommandParams); - readColorControlCommandInfo.put( - "readColorPointGYAttribute", readColorControlColorPointGYAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); Map readColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorPointGIntensityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorPointGIntensityAttribute( @@ -9391,37 +9553,37 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorPointGIntensityCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readColorPointGIntensityAttribute", - readColorControlColorPointGIntensityAttributeCommandInfo); + readColorControlColorPointGIntensityAttributeInteractionInfo); Map readColorControlColorPointBXCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorPointBXAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorPointBXAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorPointBXAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorPointBXCommandParams); - readColorControlCommandInfo.put( - "readColorPointBXAttribute", readColorControlColorPointBXAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorPointBXAttribute", readColorControlColorPointBXAttributeInteractionInfo); Map readColorControlColorPointBYCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorPointBYAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorPointBYAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorPointBYAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorPointBYCommandParams); - readColorControlCommandInfo.put( - "readColorPointBYAttribute", readColorControlColorPointBYAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); Map readColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorPointBIntensityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorPointBIntensityAttribute( @@ -9429,13 +9591,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorPointBIntensityCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readColorPointBIntensityAttribute", - readColorControlColorPointBIntensityAttributeCommandInfo); + readColorControlColorPointBIntensityAttributeInteractionInfo); Map readColorControlEnhancedCurrentHueCommandParams = new LinkedHashMap(); - CommandInfo readColorControlEnhancedCurrentHueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlEnhancedCurrentHueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readEnhancedCurrentHueAttribute( @@ -9443,36 +9605,38 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlEnhancedCurrentHueCommandParams); - readColorControlCommandInfo.put( - "readEnhancedCurrentHueAttribute", readColorControlEnhancedCurrentHueAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readEnhancedCurrentHueAttribute", + readColorControlEnhancedCurrentHueAttributeInteractionInfo); Map readColorControlEnhancedColorModeCommandParams = new LinkedHashMap(); - CommandInfo readColorControlEnhancedColorModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlEnhancedColorModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readEnhancedColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlEnhancedColorModeCommandParams); - readColorControlCommandInfo.put( - "readEnhancedColorModeAttribute", readColorControlEnhancedColorModeAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readEnhancedColorModeAttribute", + readColorControlEnhancedColorModeAttributeInteractionInfo); Map readColorControlColorLoopActiveCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorLoopActiveAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorLoopActiveAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorLoopActiveAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorLoopActiveCommandParams); - readColorControlCommandInfo.put( - "readColorLoopActiveAttribute", readColorControlColorLoopActiveAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorLoopActiveAttribute", readColorControlColorLoopActiveAttributeInteractionInfo); Map readColorControlColorLoopDirectionCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorLoopDirectionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorLoopDirectionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorLoopDirectionAttribute( @@ -9480,24 +9644,25 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorLoopDirectionCommandParams); - readColorControlCommandInfo.put( - "readColorLoopDirectionAttribute", readColorControlColorLoopDirectionAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorLoopDirectionAttribute", + readColorControlColorLoopDirectionAttributeInteractionInfo); Map readColorControlColorLoopTimeCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorLoopTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorLoopTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorLoopTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorLoopTimeCommandParams); - readColorControlCommandInfo.put( - "readColorLoopTimeAttribute", readColorControlColorLoopTimeAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorLoopTimeAttribute", readColorControlColorLoopTimeAttributeInteractionInfo); Map readColorControlColorLoopStartEnhancedHueCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorLoopStartEnhancedHueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorLoopStartEnhancedHueAttribute( @@ -9505,13 +9670,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorLoopStartEnhancedHueCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readColorLoopStartEnhancedHueAttribute", - readColorControlColorLoopStartEnhancedHueAttributeCommandInfo); + readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo); Map readColorControlColorLoopStoredEnhancedHueCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorLoopStoredEnhancedHueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorLoopStoredEnhancedHueAttribute( @@ -9519,25 +9684,26 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorLoopStoredEnhancedHueCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readColorLoopStoredEnhancedHueAttribute", - readColorControlColorLoopStoredEnhancedHueAttributeCommandInfo); + readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo); Map readColorControlColorCapabilitiesCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorCapabilitiesAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorCapabilitiesAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorCapabilitiesAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorCapabilitiesCommandParams); - readColorControlCommandInfo.put( - "readColorCapabilitiesAttribute", readColorControlColorCapabilitiesAttributeCommandInfo); + readColorControlInteractionInfo.put( + "readColorCapabilitiesAttribute", + readColorControlColorCapabilitiesAttributeInteractionInfo); Map readColorControlColorTempPhysicalMinCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorTempPhysicalMinAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorTempPhysicalMinAttribute( @@ -9545,13 +9711,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorTempPhysicalMinCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readColorTempPhysicalMinAttribute", - readColorControlColorTempPhysicalMinAttributeCommandInfo); + readColorControlColorTempPhysicalMinAttributeInteractionInfo); Map readColorControlColorTempPhysicalMaxCommandParams = new LinkedHashMap(); - CommandInfo readColorControlColorTempPhysicalMaxAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readColorTempPhysicalMaxAttribute( @@ -9559,13 +9725,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlColorTempPhysicalMaxCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readColorTempPhysicalMaxAttribute", - readColorControlColorTempPhysicalMaxAttributeCommandInfo); + readColorControlColorTempPhysicalMaxAttributeInteractionInfo); Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = new LinkedHashMap(); - CommandInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readCoupleColorTempToLevelMinMiredsAttribute( @@ -9573,13 +9739,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlCoupleColorTempToLevelMinMiredsCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readCoupleColorTempToLevelMinMiredsAttribute", - readColorControlCoupleColorTempToLevelMinMiredsAttributeCommandInfo); + readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); Map readColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); - CommandInfo readColorControlStartUpColorTemperatureMiredsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readStartUpColorTemperatureMiredsAttribute( @@ -9587,29 +9753,28 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readColorControlStartUpColorTemperatureMiredsCommandParams); - readColorControlCommandInfo.put( + readColorControlInteractionInfo.put( "readStartUpColorTemperatureMiredsAttribute", - readColorControlStartUpColorTemperatureMiredsAttributeCommandInfo); + readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); Map readColorControlClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readColorControlClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readColorControlClusterRevisionCommandParams); - readColorControlCommandInfo.put( - "readClusterRevisionAttribute", readColorControlClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("colorControl").combineCommands(readColorControlCommandInfo); - Map readContentLauncherCommandInfo = new LinkedHashMap<>(); + readColorControlInteractionInfo.put( + "readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("colorControl", readColorControlInteractionInfo); + Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); // read attribute Map readContentLauncherAcceptsHeaderListCommandParams = new LinkedHashMap(); - CommandInfo readContentLauncherAcceptsHeaderListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readContentLauncherAcceptsHeaderListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) .readAcceptsHeaderListAttribute( @@ -9618,12 +9783,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedAcceptsHeaderListAttributeCallback(), readContentLauncherAcceptsHeaderListCommandParams); - readContentLauncherCommandInfo.put( - "readAcceptsHeaderListAttribute", readContentLauncherAcceptsHeaderListAttributeCommandInfo); + readContentLauncherInteractionInfo.put( + "readAcceptsHeaderListAttribute", + readContentLauncherAcceptsHeaderListAttributeInteractionInfo); Map readContentLauncherSupportedStreamingTypesCommandParams = new LinkedHashMap(); - CommandInfo readContentLauncherSupportedStreamingTypesAttributeCommandInfo = - new CommandInfo( + InteractionInfo readContentLauncherSupportedStreamingTypesAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) .readSupportedStreamingTypesAttribute( @@ -9632,29 +9798,28 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedSupportedStreamingTypesAttributeCallback(), readContentLauncherSupportedStreamingTypesCommandParams); - readContentLauncherCommandInfo.put( + readContentLauncherInteractionInfo.put( "readSupportedStreamingTypesAttribute", - readContentLauncherSupportedStreamingTypesAttributeCommandInfo); + readContentLauncherSupportedStreamingTypesAttributeInteractionInfo); Map readContentLauncherClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readContentLauncherClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readContentLauncherClusterRevisionCommandParams); - readContentLauncherCommandInfo.put( - "readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("contentLauncher").combineCommands(readContentLauncherCommandInfo); - Map readDescriptorCommandInfo = new LinkedHashMap<>(); + readContentLauncherInteractionInfo.put( + "readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); + Map readDescriptorInteractionInfo = new LinkedHashMap<>(); // read attribute Map readDescriptorDeviceListCommandParams = new LinkedHashMap(); - CommandInfo readDescriptorDeviceListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DescriptorCluster) cluster) .readDeviceListAttribute( @@ -9662,12 +9827,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedDeviceListAttributeCallback(), readDescriptorDeviceListCommandParams); - readDescriptorCommandInfo.put( - "readDeviceListAttribute", readDescriptorDeviceListAttributeCommandInfo); + readDescriptorInteractionInfo.put( + "readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); Map readDescriptorServerListCommandParams = new LinkedHashMap(); - CommandInfo readDescriptorServerListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readDescriptorServerListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DescriptorCluster) cluster) .readServerListAttribute( @@ -9675,12 +9840,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedServerListAttributeCallback(), readDescriptorServerListCommandParams); - readDescriptorCommandInfo.put( - "readServerListAttribute", readDescriptorServerListAttributeCommandInfo); + readDescriptorInteractionInfo.put( + "readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); Map readDescriptorClientListCommandParams = new LinkedHashMap(); - CommandInfo readDescriptorClientListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readDescriptorClientListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DescriptorCluster) cluster) .readClientListAttribute( @@ -9688,12 +9853,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedClientListAttributeCallback(), readDescriptorClientListCommandParams); - readDescriptorCommandInfo.put( - "readClientListAttribute", readDescriptorClientListAttributeCommandInfo); + readDescriptorInteractionInfo.put( + "readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); Map readDescriptorPartsListCommandParams = new LinkedHashMap(); - CommandInfo readDescriptorPartsListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readDescriptorPartsListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DescriptorCluster) cluster) .readPartsListAttribute( @@ -9701,367 +9866,371 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedPartsListAttributeCallback(), readDescriptorPartsListCommandParams); - readDescriptorCommandInfo.put( - "readPartsListAttribute", readDescriptorPartsListAttributeCommandInfo); + readDescriptorInteractionInfo.put( + "readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); Map readDescriptorClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readDescriptorClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DescriptorCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readDescriptorClusterRevisionCommandParams); - readDescriptorCommandInfo.put( - "readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("descriptor").combineCommands(readDescriptorCommandInfo); - Map readDiagnosticLogsCommandInfo = new LinkedHashMap<>(); + readDescriptorInteractionInfo.put( + "readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("descriptor", readDescriptorInteractionInfo); + Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); // read attribute - // combine the read Attribute into the original commands - clusterMap.get("diagnosticLogs").combineCommands(readDiagnosticLogsCommandInfo); - Map readDoorLockCommandInfo = new LinkedHashMap<>(); + readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); + Map readDoorLockInteractionInfo = new LinkedHashMap<>(); // read attribute Map readDoorLockLockStateCommandParams = new LinkedHashMap(); - CommandInfo readDoorLockLockStateAttributeCommandInfo = - new CommandInfo( + InteractionInfo readDoorLockLockStateAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .readLockStateAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readDoorLockLockStateCommandParams); - readDoorLockCommandInfo.put( - "readLockStateAttribute", readDoorLockLockStateAttributeCommandInfo); + readDoorLockInteractionInfo.put( + "readLockStateAttribute", readDoorLockLockStateAttributeInteractionInfo); Map readDoorLockLockTypeCommandParams = new LinkedHashMap(); - CommandInfo readDoorLockLockTypeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readDoorLockLockTypeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .readLockTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readDoorLockLockTypeCommandParams); - readDoorLockCommandInfo.put("readLockTypeAttribute", readDoorLockLockTypeAttributeCommandInfo); + readDoorLockInteractionInfo.put( + "readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); Map readDoorLockActuatorEnabledCommandParams = new LinkedHashMap(); - CommandInfo readDoorLockActuatorEnabledAttributeCommandInfo = - new CommandInfo( + InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .readActuatorEnabledAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readDoorLockActuatorEnabledCommandParams); - readDoorLockCommandInfo.put( - "readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeCommandInfo); + readDoorLockInteractionInfo.put( + "readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); Map readDoorLockClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readDoorLockClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readDoorLockClusterRevisionCommandParams); - readDoorLockCommandInfo.put( - "readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("doorLock").combineCommands(readDoorLockCommandInfo); - Map readElectricalMeasurementCommandInfo = new LinkedHashMap<>(); + readDoorLockInteractionInfo.put( + "readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("doorLock", readDoorLockInteractionInfo); + Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); // read attribute Map readElectricalMeasurementMeasurementTypeCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementMeasurementTypeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readMeasurementTypeAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readElectricalMeasurementMeasurementTypeCommandParams); - readElectricalMeasurementCommandInfo.put( + readElectricalMeasurementInteractionInfo.put( "readMeasurementTypeAttribute", - readElectricalMeasurementMeasurementTypeAttributeCommandInfo); + readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); Map readElectricalMeasurementTotalActivePowerCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementTotalActivePowerAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readTotalActivePowerAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readElectricalMeasurementTotalActivePowerCommandParams); - readElectricalMeasurementCommandInfo.put( + readElectricalMeasurementInteractionInfo.put( "readTotalActivePowerAttribute", - readElectricalMeasurementTotalActivePowerAttributeCommandInfo); + readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); Map readElectricalMeasurementRmsVoltageCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementRmsVoltageAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readRmsVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementRmsVoltageCommandParams); - readElectricalMeasurementCommandInfo.put( - "readRmsVoltageAttribute", readElectricalMeasurementRmsVoltageAttributeCommandInfo); + readElectricalMeasurementInteractionInfo.put( + "readRmsVoltageAttribute", readElectricalMeasurementRmsVoltageAttributeInteractionInfo); Map readElectricalMeasurementRmsVoltageMinCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementRmsVoltageMinAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readRmsVoltageMinAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementRmsVoltageMinCommandParams); - readElectricalMeasurementCommandInfo.put( - "readRmsVoltageMinAttribute", readElectricalMeasurementRmsVoltageMinAttributeCommandInfo); + readElectricalMeasurementInteractionInfo.put( + "readRmsVoltageMinAttribute", + readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo); Map readElectricalMeasurementRmsVoltageMaxCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementRmsVoltageMaxAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readRmsVoltageMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementRmsVoltageMaxCommandParams); - readElectricalMeasurementCommandInfo.put( - "readRmsVoltageMaxAttribute", readElectricalMeasurementRmsVoltageMaxAttributeCommandInfo); + readElectricalMeasurementInteractionInfo.put( + "readRmsVoltageMaxAttribute", + readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo); Map readElectricalMeasurementRmsCurrentCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementRmsCurrentAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementRmsCurrentAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readRmsCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementRmsCurrentCommandParams); - readElectricalMeasurementCommandInfo.put( - "readRmsCurrentAttribute", readElectricalMeasurementRmsCurrentAttributeCommandInfo); + readElectricalMeasurementInteractionInfo.put( + "readRmsCurrentAttribute", readElectricalMeasurementRmsCurrentAttributeInteractionInfo); Map readElectricalMeasurementRmsCurrentMinCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementRmsCurrentMinAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readRmsCurrentMinAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementRmsCurrentMinCommandParams); - readElectricalMeasurementCommandInfo.put( - "readRmsCurrentMinAttribute", readElectricalMeasurementRmsCurrentMinAttributeCommandInfo); + readElectricalMeasurementInteractionInfo.put( + "readRmsCurrentMinAttribute", + readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo); Map readElectricalMeasurementRmsCurrentMaxCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementRmsCurrentMaxAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readRmsCurrentMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementRmsCurrentMaxCommandParams); - readElectricalMeasurementCommandInfo.put( - "readRmsCurrentMaxAttribute", readElectricalMeasurementRmsCurrentMaxAttributeCommandInfo); + readElectricalMeasurementInteractionInfo.put( + "readRmsCurrentMaxAttribute", + readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo); Map readElectricalMeasurementActivePowerCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementActivePowerAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementActivePowerAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readActivePowerAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementActivePowerCommandParams); - readElectricalMeasurementCommandInfo.put( - "readActivePowerAttribute", readElectricalMeasurementActivePowerAttributeCommandInfo); + readElectricalMeasurementInteractionInfo.put( + "readActivePowerAttribute", readElectricalMeasurementActivePowerAttributeInteractionInfo); Map readElectricalMeasurementActivePowerMinCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementActivePowerMinAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementActivePowerMinAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readActivePowerMinAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementActivePowerMinCommandParams); - readElectricalMeasurementCommandInfo.put( - "readActivePowerMinAttribute", readElectricalMeasurementActivePowerMinAttributeCommandInfo); + readElectricalMeasurementInteractionInfo.put( + "readActivePowerMinAttribute", + readElectricalMeasurementActivePowerMinAttributeInteractionInfo); Map readElectricalMeasurementActivePowerMaxCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementActivePowerMaxAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementActivePowerMaxAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readActivePowerMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementActivePowerMaxCommandParams); - readElectricalMeasurementCommandInfo.put( - "readActivePowerMaxAttribute", readElectricalMeasurementActivePowerMaxAttributeCommandInfo); + readElectricalMeasurementInteractionInfo.put( + "readActivePowerMaxAttribute", + readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); Map readElectricalMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readElectricalMeasurementClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ElectricalMeasurementCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readElectricalMeasurementClusterRevisionCommandParams); - readElectricalMeasurementCommandInfo.put( + readElectricalMeasurementInteractionInfo.put( "readClusterRevisionAttribute", - readElectricalMeasurementClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("electricalMeasurement").combineCommands(readElectricalMeasurementCommandInfo); - Map readEthernetNetworkDiagnosticsCommandInfo = new LinkedHashMap<>(); + readElectricalMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); + Map readEthernetNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); // read attribute Map readEthernetNetworkDiagnosticsPHYRateCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsPHYRateAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readPHYRateAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readEthernetNetworkDiagnosticsPHYRateCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( - "readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeCommandInfo); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsFullDuplexAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readFullDuplexAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readEthernetNetworkDiagnosticsFullDuplexCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( - "readFullDuplexAttribute", readEthernetNetworkDiagnosticsFullDuplexAttributeCommandInfo); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readFullDuplexAttribute", + readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readPacketRxCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readEthernetNetworkDiagnosticsPacketRxCountCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( + readEthernetNetworkDiagnosticsInteractionInfo.put( "readPacketRxCountAttribute", - readEthernetNetworkDiagnosticsPacketRxCountAttributeCommandInfo); + readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readPacketTxCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readEthernetNetworkDiagnosticsPacketTxCountCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( + readEthernetNetworkDiagnosticsInteractionInfo.put( "readPacketTxCountAttribute", - readEthernetNetworkDiagnosticsPacketTxCountAttributeCommandInfo); + readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsTxErrCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readTxErrCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readEthernetNetworkDiagnosticsTxErrCountCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( - "readTxErrCountAttribute", readEthernetNetworkDiagnosticsTxErrCountAttributeCommandInfo); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readTxErrCountAttribute", + readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsCollisionCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readCollisionCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readEthernetNetworkDiagnosticsCollisionCountCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( + readEthernetNetworkDiagnosticsInteractionInfo.put( "readCollisionCountAttribute", - readEthernetNetworkDiagnosticsCollisionCountAttributeCommandInfo); + readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsOverrunCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readEthernetNetworkDiagnosticsOverrunCountCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( + readEthernetNetworkDiagnosticsInteractionInfo.put( "readOverrunCountAttribute", - readEthernetNetworkDiagnosticsOverrunCountAttributeCommandInfo); + readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readCarrierDetectAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readEthernetNetworkDiagnosticsCarrierDetectCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( + readEthernetNetworkDiagnosticsInteractionInfo.put( "readCarrierDetectAttribute", - readEthernetNetworkDiagnosticsCarrierDetectAttributeCommandInfo); + readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readTimeSinceResetAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readEthernetNetworkDiagnosticsTimeSinceResetCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( + readEthernetNetworkDiagnosticsInteractionInfo.put( "readTimeSinceResetAttribute", - readEthernetNetworkDiagnosticsTimeSinceResetAttributeCommandInfo); + readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); Map readEthernetNetworkDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readEthernetNetworkDiagnosticsClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readEthernetNetworkDiagnosticsClusterRevisionCommandParams); - readEthernetNetworkDiagnosticsCommandInfo.put( + readEthernetNetworkDiagnosticsInteractionInfo.put( "readClusterRevisionAttribute", - readEthernetNetworkDiagnosticsClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap - .get("ethernetNetworkDiagnostics") - .combineCommands(readEthernetNetworkDiagnosticsCommandInfo); - Map readFixedLabelCommandInfo = new LinkedHashMap<>(); + readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); + Map readFixedLabelInteractionInfo = new LinkedHashMap<>(); // read attribute Map readFixedLabelLabelListCommandParams = new LinkedHashMap(); - CommandInfo readFixedLabelLabelListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.FixedLabelCluster) cluster) .readLabelListAttribute( @@ -10069,105 +10238,105 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLabelListAttributeCallback(), readFixedLabelLabelListCommandParams); - readFixedLabelCommandInfo.put( - "readLabelListAttribute", readFixedLabelLabelListAttributeCommandInfo); + readFixedLabelInteractionInfo.put( + "readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); Map readFixedLabelClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readFixedLabelClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.FixedLabelCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readFixedLabelClusterRevisionCommandParams); - readFixedLabelCommandInfo.put( - "readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("fixedLabel").combineCommands(readFixedLabelCommandInfo); - Map readFlowMeasurementCommandInfo = new LinkedHashMap<>(); + readFixedLabelInteractionInfo.put( + "readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); + Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); // read attribute Map readFlowMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readFlowMeasurementMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.FlowMeasurementCluster) cluster) .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readFlowMeasurementMeasuredValueCommandParams); - readFlowMeasurementCommandInfo.put( - "readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeCommandInfo); + readFlowMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); Map readFlowMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readFlowMeasurementMinMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.FlowMeasurementCluster) cluster) .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readFlowMeasurementMinMeasuredValueCommandParams); - readFlowMeasurementCommandInfo.put( - "readMinMeasuredValueAttribute", readFlowMeasurementMinMeasuredValueAttributeCommandInfo); + readFlowMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); Map readFlowMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readFlowMeasurementMaxMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.FlowMeasurementCluster) cluster) .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readFlowMeasurementMaxMeasuredValueCommandParams); - readFlowMeasurementCommandInfo.put( - "readMaxMeasuredValueAttribute", readFlowMeasurementMaxMeasuredValueAttributeCommandInfo); + readFlowMeasurementInteractionInfo.put( + "readMaxMeasuredValueAttribute", + readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo); Map readFlowMeasurementToleranceCommandParams = new LinkedHashMap(); - CommandInfo readFlowMeasurementToleranceAttributeCommandInfo = - new CommandInfo( + InteractionInfo readFlowMeasurementToleranceAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.FlowMeasurementCluster) cluster) .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readFlowMeasurementToleranceCommandParams); - readFlowMeasurementCommandInfo.put( - "readToleranceAttribute", readFlowMeasurementToleranceAttributeCommandInfo); + readFlowMeasurementInteractionInfo.put( + "readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); Map readFlowMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readFlowMeasurementClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.FlowMeasurementCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readFlowMeasurementClusterRevisionCommandParams); - readFlowMeasurementCommandInfo.put( - "readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("flowMeasurement").combineCommands(readFlowMeasurementCommandInfo); - Map readGeneralCommissioningCommandInfo = new LinkedHashMap<>(); + readFlowMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); + Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); // read attribute Map readGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); - CommandInfo readGeneralCommissioningBreadcrumbAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) .readBreadcrumbAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readGeneralCommissioningBreadcrumbCommandParams); - readGeneralCommissioningCommandInfo.put( - "readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeCommandInfo); + readGeneralCommissioningInteractionInfo.put( + "readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); Map readGeneralCommissioningBasicCommissioningInfoListCommandParams = new LinkedHashMap(); - CommandInfo readGeneralCommissioningBasicCommissioningInfoListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) .readBasicCommissioningInfoListAttribute( @@ -10177,30 +10346,29 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedBasicCommissioningInfoListAttributeCallback(), readGeneralCommissioningBasicCommissioningInfoListCommandParams); - readGeneralCommissioningCommandInfo.put( + readGeneralCommissioningInteractionInfo.put( "readBasicCommissioningInfoListAttribute", - readGeneralCommissioningBasicCommissioningInfoListAttributeCommandInfo); + readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); Map readGeneralCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readGeneralCommissioningClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readGeneralCommissioningClusterRevisionCommandParams); - readGeneralCommissioningCommandInfo.put( + readGeneralCommissioningInteractionInfo.put( "readClusterRevisionAttribute", - readGeneralCommissioningClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("generalCommissioning").combineCommands(readGeneralCommissioningCommandInfo); - Map readGeneralDiagnosticsCommandInfo = new LinkedHashMap<>(); + readGeneralCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); + Map readGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); // read attribute Map readGeneralDiagnosticsNetworkInterfacesCommandParams = new LinkedHashMap(); - CommandInfo readGeneralDiagnosticsNetworkInterfacesAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralDiagnosticsCluster) cluster) .readNetworkInterfacesAttribute( @@ -10209,37 +10377,37 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedNetworkInterfacesAttributeCallback(), readGeneralDiagnosticsNetworkInterfacesCommandParams); - readGeneralDiagnosticsCommandInfo.put( + readGeneralDiagnosticsInteractionInfo.put( "readNetworkInterfacesAttribute", - readGeneralDiagnosticsNetworkInterfacesAttributeCommandInfo); + readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo); Map readGeneralDiagnosticsRebootCountCommandParams = new LinkedHashMap(); - CommandInfo readGeneralDiagnosticsRebootCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGeneralDiagnosticsRebootCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralDiagnosticsCluster) cluster) .readRebootCountAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readGeneralDiagnosticsRebootCountCommandParams); - readGeneralDiagnosticsCommandInfo.put( - "readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeCommandInfo); + readGeneralDiagnosticsInteractionInfo.put( + "readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); Map readGeneralDiagnosticsUpTimeCommandParams = new LinkedHashMap(); - CommandInfo readGeneralDiagnosticsUpTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralDiagnosticsCluster) cluster) .readUpTimeAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readGeneralDiagnosticsUpTimeCommandParams); - readGeneralDiagnosticsCommandInfo.put( - "readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeCommandInfo); + readGeneralDiagnosticsInteractionInfo.put( + "readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = new LinkedHashMap(); - CommandInfo readGeneralDiagnosticsTotalOperationalHoursAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralDiagnosticsCluster) cluster) .readTotalOperationalHoursAttribute( @@ -10247,41 +10415,41 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readGeneralDiagnosticsTotalOperationalHoursCommandParams); - readGeneralDiagnosticsCommandInfo.put( + readGeneralDiagnosticsInteractionInfo.put( "readTotalOperationalHoursAttribute", - readGeneralDiagnosticsTotalOperationalHoursAttributeCommandInfo); + readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); Map readGeneralDiagnosticsBootReasonsCommandParams = new LinkedHashMap(); - CommandInfo readGeneralDiagnosticsBootReasonsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralDiagnosticsCluster) cluster) .readBootReasonsAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readGeneralDiagnosticsBootReasonsCommandParams); - readGeneralDiagnosticsCommandInfo.put( - "readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeCommandInfo); + readGeneralDiagnosticsInteractionInfo.put( + "readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); Map readGeneralDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readGeneralDiagnosticsClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralDiagnosticsCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readGeneralDiagnosticsClusterRevisionCommandParams); - readGeneralDiagnosticsCommandInfo.put( - "readClusterRevisionAttribute", readGeneralDiagnosticsClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("generalDiagnostics").combineCommands(readGeneralDiagnosticsCommandInfo); - Map readGroupKeyManagementCommandInfo = new LinkedHashMap<>(); + readGeneralDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); + Map readGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); // read attribute Map readGroupKeyManagementGroupsCommandParams = new LinkedHashMap(); - CommandInfo readGroupKeyManagementGroupsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGroupKeyManagementGroupsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .readGroupsAttribute( @@ -10289,12 +10457,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedGroupsAttributeCallback(), readGroupKeyManagementGroupsCommandParams); - readGroupKeyManagementCommandInfo.put( - "readGroupsAttribute", readGroupKeyManagementGroupsAttributeCommandInfo); + readGroupKeyManagementInteractionInfo.put( + "readGroupsAttribute", readGroupKeyManagementGroupsAttributeInteractionInfo); Map readGroupKeyManagementGroupKeysCommandParams = new LinkedHashMap(); - CommandInfo readGroupKeyManagementGroupKeysAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGroupKeyManagementGroupKeysAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .readGroupKeysAttribute( @@ -10302,288 +10470,285 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedGroupKeysAttributeCallback(), readGroupKeyManagementGroupKeysCommandParams); - readGroupKeyManagementCommandInfo.put( - "readGroupKeysAttribute", readGroupKeyManagementGroupKeysAttributeCommandInfo); + readGroupKeyManagementInteractionInfo.put( + "readGroupKeysAttribute", readGroupKeyManagementGroupKeysAttributeInteractionInfo); Map readGroupKeyManagementClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readGroupKeyManagementClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readGroupKeyManagementClusterRevisionCommandParams); - readGroupKeyManagementCommandInfo.put( - "readClusterRevisionAttribute", readGroupKeyManagementClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("groupKeyManagement").combineCommands(readGroupKeyManagementCommandInfo); - Map readGroupsCommandInfo = new LinkedHashMap<>(); + readGroupKeyManagementInteractionInfo.put( + "readClusterRevisionAttribute", + readGroupKeyManagementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); + Map readGroupsInteractionInfo = new LinkedHashMap<>(); // read attribute Map readGroupsNameSupportCommandParams = new LinkedHashMap(); - CommandInfo readGroupsNameSupportAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGroupsNameSupportAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readGroupsNameSupportCommandParams); - readGroupsCommandInfo.put( - "readNameSupportAttribute", readGroupsNameSupportAttributeCommandInfo); + readGroupsInteractionInfo.put( + "readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); Map readGroupsClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readGroupsClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readGroupsClusterRevisionCommandParams); - readGroupsCommandInfo.put( - "readClusterRevisionAttribute", readGroupsClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("groups").combineCommands(readGroupsCommandInfo); - Map readIdentifyCommandInfo = new LinkedHashMap<>(); + readGroupsInteractionInfo.put( + "readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groups", readGroupsInteractionInfo); + Map readIdentifyInteractionInfo = new LinkedHashMap<>(); // read attribute Map readIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); - CommandInfo readIdentifyIdentifyTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .readIdentifyTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readIdentifyIdentifyTimeCommandParams); - readIdentifyCommandInfo.put( - "readIdentifyTimeAttribute", readIdentifyIdentifyTimeAttributeCommandInfo); + readIdentifyInteractionInfo.put( + "readIdentifyTimeAttribute", readIdentifyIdentifyTimeAttributeInteractionInfo); Map readIdentifyIdentifyTypeCommandParams = new LinkedHashMap(); - CommandInfo readIdentifyIdentifyTypeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readIdentifyIdentifyTypeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .readIdentifyTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readIdentifyIdentifyTypeCommandParams); - readIdentifyCommandInfo.put( - "readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeCommandInfo); + readIdentifyInteractionInfo.put( + "readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); Map readIdentifyClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readIdentifyClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readIdentifyClusterRevisionCommandParams); - readIdentifyCommandInfo.put( - "readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("identify").combineCommands(readIdentifyCommandInfo); - Map readIlluminanceMeasurementCommandInfo = new LinkedHashMap<>(); + readIdentifyInteractionInfo.put( + "readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("identify", readIdentifyInteractionInfo); + Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); // read attribute Map readIlluminanceMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readIlluminanceMeasurementMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IlluminanceMeasurementCluster) cluster) .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readIlluminanceMeasurementMeasuredValueCommandParams); - readIlluminanceMeasurementCommandInfo.put( - "readMeasuredValueAttribute", readIlluminanceMeasurementMeasuredValueAttributeCommandInfo); + readIlluminanceMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); Map readIlluminanceMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readIlluminanceMeasurementMinMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IlluminanceMeasurementCluster) cluster) .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readIlluminanceMeasurementMinMeasuredValueCommandParams); - readIlluminanceMeasurementCommandInfo.put( + readIlluminanceMeasurementInteractionInfo.put( "readMinMeasuredValueAttribute", - readIlluminanceMeasurementMinMeasuredValueAttributeCommandInfo); + readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readIlluminanceMeasurementMaxMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IlluminanceMeasurementCluster) cluster) .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readIlluminanceMeasurementMaxMeasuredValueCommandParams); - readIlluminanceMeasurementCommandInfo.put( + readIlluminanceMeasurementInteractionInfo.put( "readMaxMeasuredValueAttribute", - readIlluminanceMeasurementMaxMeasuredValueAttributeCommandInfo); + readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo); Map readIlluminanceMeasurementToleranceCommandParams = new LinkedHashMap(); - CommandInfo readIlluminanceMeasurementToleranceAttributeCommandInfo = - new CommandInfo( + InteractionInfo readIlluminanceMeasurementToleranceAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IlluminanceMeasurementCluster) cluster) .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readIlluminanceMeasurementToleranceCommandParams); - readIlluminanceMeasurementCommandInfo.put( - "readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeCommandInfo); + readIlluminanceMeasurementInteractionInfo.put( + "readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); Map readIlluminanceMeasurementLightSensorTypeCommandParams = new LinkedHashMap(); - CommandInfo readIlluminanceMeasurementLightSensorTypeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IlluminanceMeasurementCluster) cluster) .readLightSensorTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readIlluminanceMeasurementLightSensorTypeCommandParams); - readIlluminanceMeasurementCommandInfo.put( + readIlluminanceMeasurementInteractionInfo.put( "readLightSensorTypeAttribute", - readIlluminanceMeasurementLightSensorTypeAttributeCommandInfo); + readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); Map readIlluminanceMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readIlluminanceMeasurementClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IlluminanceMeasurementCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readIlluminanceMeasurementClusterRevisionCommandParams); - readIlluminanceMeasurementCommandInfo.put( + readIlluminanceMeasurementInteractionInfo.put( "readClusterRevisionAttribute", - readIlluminanceMeasurementClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("illuminanceMeasurement").combineCommands(readIlluminanceMeasurementCommandInfo); - Map readKeypadInputCommandInfo = new LinkedHashMap<>(); + readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); + Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); // read attribute Map readKeypadInputClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readKeypadInputClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.KeypadInputCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readKeypadInputClusterRevisionCommandParams); - readKeypadInputCommandInfo.put( - "readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("keypadInput").combineCommands(readKeypadInputCommandInfo); - Map readLevelControlCommandInfo = new LinkedHashMap<>(); + readKeypadInputInteractionInfo.put( + "readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); + Map readLevelControlInteractionInfo = new LinkedHashMap<>(); // read attribute Map readLevelControlCurrentLevelCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlCurrentLevelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readCurrentLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlCurrentLevelCommandParams); - readLevelControlCommandInfo.put( - "readCurrentLevelAttribute", readLevelControlCurrentLevelAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readCurrentLevelAttribute", readLevelControlCurrentLevelAttributeInteractionInfo); Map readLevelControlRemainingTimeCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlRemainingTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlRemainingTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readRemainingTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlRemainingTimeCommandParams); - readLevelControlCommandInfo.put( - "readRemainingTimeAttribute", readLevelControlRemainingTimeAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readRemainingTimeAttribute", readLevelControlRemainingTimeAttributeInteractionInfo); Map readLevelControlMinLevelCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlMinLevelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlMinLevelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readMinLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlMinLevelCommandParams); - readLevelControlCommandInfo.put( - "readMinLevelAttribute", readLevelControlMinLevelAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readMinLevelAttribute", readLevelControlMinLevelAttributeInteractionInfo); Map readLevelControlMaxLevelCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlMaxLevelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlMaxLevelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readMaxLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlMaxLevelCommandParams); - readLevelControlCommandInfo.put( - "readMaxLevelAttribute", readLevelControlMaxLevelAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readMaxLevelAttribute", readLevelControlMaxLevelAttributeInteractionInfo); Map readLevelControlCurrentFrequencyCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlCurrentFrequencyAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlCurrentFrequencyAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readCurrentFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlCurrentFrequencyCommandParams); - readLevelControlCommandInfo.put( - "readCurrentFrequencyAttribute", readLevelControlCurrentFrequencyAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readCurrentFrequencyAttribute", readLevelControlCurrentFrequencyAttributeInteractionInfo); Map readLevelControlMinFrequencyCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlMinFrequencyAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlMinFrequencyAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readMinFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlMinFrequencyCommandParams); - readLevelControlCommandInfo.put( - "readMinFrequencyAttribute", readLevelControlMinFrequencyAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readMinFrequencyAttribute", readLevelControlMinFrequencyAttributeInteractionInfo); Map readLevelControlMaxFrequencyCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlMaxFrequencyAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlMaxFrequencyAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readMaxFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlMaxFrequencyCommandParams); - readLevelControlCommandInfo.put( - "readMaxFrequencyAttribute", readLevelControlMaxFrequencyAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readMaxFrequencyAttribute", readLevelControlMaxFrequencyAttributeInteractionInfo); Map readLevelControlOptionsCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlOptionsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlOptionsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readOptionsAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlOptionsCommandParams); - readLevelControlCommandInfo.put( - "readOptionsAttribute", readLevelControlOptionsAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readOptionsAttribute", readLevelControlOptionsAttributeInteractionInfo); Map readLevelControlOnOffTransitionTimeCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlOnOffTransitionTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlOnOffTransitionTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readOnOffTransitionTimeAttribute( @@ -10591,61 +10756,62 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlOnOffTransitionTimeCommandParams); - readLevelControlCommandInfo.put( + readLevelControlInteractionInfo.put( "readOnOffTransitionTimeAttribute", - readLevelControlOnOffTransitionTimeAttributeCommandInfo); + readLevelControlOnOffTransitionTimeAttributeInteractionInfo); Map readLevelControlOnLevelCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlOnLevelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readOnLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlOnLevelCommandParams); - readLevelControlCommandInfo.put( - "readOnLevelAttribute", readLevelControlOnLevelAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); Map readLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlOnTransitionTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readOnTransitionTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlOnTransitionTimeCommandParams); - readLevelControlCommandInfo.put( - "readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); Map readLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlOffTransitionTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readOffTransitionTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlOffTransitionTimeCommandParams); - readLevelControlCommandInfo.put( - "readOffTransitionTimeAttribute", readLevelControlOffTransitionTimeAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readOffTransitionTimeAttribute", + readLevelControlOffTransitionTimeAttributeInteractionInfo); Map readLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlDefaultMoveRateAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readDefaultMoveRateAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlDefaultMoveRateCommandParams); - readLevelControlCommandInfo.put( - "readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeCommandInfo); + readLevelControlInteractionInfo.put( + "readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); Map readLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlStartUpCurrentLevelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readStartUpCurrentLevelAttribute( @@ -10653,45 +10819,43 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlStartUpCurrentLevelCommandParams); - readLevelControlCommandInfo.put( + readLevelControlInteractionInfo.put( "readStartUpCurrentLevelAttribute", - readLevelControlStartUpCurrentLevelAttributeCommandInfo); + readLevelControlStartUpCurrentLevelAttributeInteractionInfo); Map readLevelControlClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readLevelControlClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLevelControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLevelControlClusterRevisionCommandParams); - readLevelControlCommandInfo.put( - "readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("levelControl").combineCommands(readLevelControlCommandInfo); - Map readLowPowerCommandInfo = new LinkedHashMap<>(); + readLevelControlInteractionInfo.put( + "readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("levelControl", readLevelControlInteractionInfo); + Map readLowPowerInteractionInfo = new LinkedHashMap<>(); // read attribute Map readLowPowerClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readLowPowerClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LowPowerCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readLowPowerClusterRevisionCommandParams); - readLowPowerCommandInfo.put( - "readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("lowPower").combineCommands(readLowPowerCommandInfo); - Map readMediaInputCommandInfo = new LinkedHashMap<>(); + readLowPowerInteractionInfo.put( + "readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("lowPower", readLowPowerInteractionInfo); + Map readMediaInputInteractionInfo = new LinkedHashMap<>(); // read attribute Map readMediaInputMediaInputListCommandParams = new LinkedHashMap(); - CommandInfo readMediaInputMediaInputListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .readMediaInputListAttribute( @@ -10699,164 +10863,163 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedMediaInputListAttributeCallback(), readMediaInputMediaInputListCommandParams); - readMediaInputCommandInfo.put( - "readMediaInputListAttribute", readMediaInputMediaInputListAttributeCommandInfo); + readMediaInputInteractionInfo.put( + "readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); Map readMediaInputCurrentMediaInputCommandParams = new LinkedHashMap(); - CommandInfo readMediaInputCurrentMediaInputAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .readCurrentMediaInputAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readMediaInputCurrentMediaInputCommandParams); - readMediaInputCommandInfo.put( - "readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeCommandInfo); + readMediaInputInteractionInfo.put( + "readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); Map readMediaInputClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readMediaInputClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readMediaInputClusterRevisionCommandParams); - readMediaInputCommandInfo.put( - "readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("mediaInput").combineCommands(readMediaInputCommandInfo); - Map readMediaPlaybackCommandInfo = new LinkedHashMap<>(); + readMediaInputInteractionInfo.put( + "readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); + Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); // read attribute Map readMediaPlaybackPlaybackStateCommandParams = new LinkedHashMap(); - CommandInfo readMediaPlaybackPlaybackStateAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .readPlaybackStateAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readMediaPlaybackPlaybackStateCommandParams); - readMediaPlaybackCommandInfo.put( - "readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeCommandInfo); + readMediaPlaybackInteractionInfo.put( + "readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); Map readMediaPlaybackStartTimeCommandParams = new LinkedHashMap(); - CommandInfo readMediaPlaybackStartTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .readStartTimeAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readMediaPlaybackStartTimeCommandParams); - readMediaPlaybackCommandInfo.put( - "readStartTimeAttribute", readMediaPlaybackStartTimeAttributeCommandInfo); + readMediaPlaybackInteractionInfo.put( + "readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); Map readMediaPlaybackDurationCommandParams = new LinkedHashMap(); - CommandInfo readMediaPlaybackDurationAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .readDurationAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readMediaPlaybackDurationCommandParams); - readMediaPlaybackCommandInfo.put( - "readDurationAttribute", readMediaPlaybackDurationAttributeCommandInfo); + readMediaPlaybackInteractionInfo.put( + "readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); Map readMediaPlaybackPositionUpdatedAtCommandParams = new LinkedHashMap(); - CommandInfo readMediaPlaybackPositionUpdatedAtAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaPlaybackPositionUpdatedAtAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .readPositionUpdatedAtAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readMediaPlaybackPositionUpdatedAtCommandParams); - readMediaPlaybackCommandInfo.put( - "readPositionUpdatedAtAttribute", readMediaPlaybackPositionUpdatedAtAttributeCommandInfo); + readMediaPlaybackInteractionInfo.put( + "readPositionUpdatedAtAttribute", + readMediaPlaybackPositionUpdatedAtAttributeInteractionInfo); Map readMediaPlaybackPositionCommandParams = new LinkedHashMap(); - CommandInfo readMediaPlaybackPositionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaPlaybackPositionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .readPositionAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readMediaPlaybackPositionCommandParams); - readMediaPlaybackCommandInfo.put( - "readPositionAttribute", readMediaPlaybackPositionAttributeCommandInfo); + readMediaPlaybackInteractionInfo.put( + "readPositionAttribute", readMediaPlaybackPositionAttributeInteractionInfo); Map readMediaPlaybackPlaybackSpeedCommandParams = new LinkedHashMap(); - CommandInfo readMediaPlaybackPlaybackSpeedAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .readPlaybackSpeedAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readMediaPlaybackPlaybackSpeedCommandParams); - readMediaPlaybackCommandInfo.put( - "readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeCommandInfo); + readMediaPlaybackInteractionInfo.put( + "readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); Map readMediaPlaybackSeekRangeEndCommandParams = new LinkedHashMap(); - CommandInfo readMediaPlaybackSeekRangeEndAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .readSeekRangeEndAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readMediaPlaybackSeekRangeEndCommandParams); - readMediaPlaybackCommandInfo.put( - "readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeCommandInfo); + readMediaPlaybackInteractionInfo.put( + "readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); Map readMediaPlaybackSeekRangeStartCommandParams = new LinkedHashMap(); - CommandInfo readMediaPlaybackSeekRangeStartAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .readSeekRangeStartAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readMediaPlaybackSeekRangeStartCommandParams); - readMediaPlaybackCommandInfo.put( - "readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeCommandInfo); + readMediaPlaybackInteractionInfo.put( + "readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); Map readMediaPlaybackClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readMediaPlaybackClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readMediaPlaybackClusterRevisionCommandParams); - readMediaPlaybackCommandInfo.put( - "readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("mediaPlayback").combineCommands(readMediaPlaybackCommandInfo); - Map readModeSelectCommandInfo = new LinkedHashMap<>(); + readMediaPlaybackInteractionInfo.put( + "readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); + Map readModeSelectInteractionInfo = new LinkedHashMap<>(); // read attribute Map readModeSelectCurrentModeCommandParams = new LinkedHashMap(); - CommandInfo readModeSelectCurrentModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .readCurrentModeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readModeSelectCurrentModeCommandParams); - readModeSelectCommandInfo.put( - "readCurrentModeAttribute", readModeSelectCurrentModeAttributeCommandInfo); + readModeSelectInteractionInfo.put( + "readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); Map readModeSelectSupportedModesCommandParams = new LinkedHashMap(); - CommandInfo readModeSelectSupportedModesAttributeCommandInfo = - new CommandInfo( + InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .readSupportedModesAttribute( @@ -10864,112 +11027,110 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedSupportedModesAttributeCallback(), readModeSelectSupportedModesCommandParams); - readModeSelectCommandInfo.put( - "readSupportedModesAttribute", readModeSelectSupportedModesAttributeCommandInfo); + readModeSelectInteractionInfo.put( + "readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); Map readModeSelectOnModeCommandParams = new LinkedHashMap(); - CommandInfo readModeSelectOnModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readModeSelectOnModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .readOnModeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readModeSelectOnModeCommandParams); - readModeSelectCommandInfo.put("readOnModeAttribute", readModeSelectOnModeAttributeCommandInfo); + readModeSelectInteractionInfo.put( + "readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); Map readModeSelectStartUpModeCommandParams = new LinkedHashMap(); - CommandInfo readModeSelectStartUpModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .readStartUpModeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readModeSelectStartUpModeCommandParams); - readModeSelectCommandInfo.put( - "readStartUpModeAttribute", readModeSelectStartUpModeAttributeCommandInfo); + readModeSelectInteractionInfo.put( + "readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); Map readModeSelectDescriptionCommandParams = new LinkedHashMap(); - CommandInfo readModeSelectDescriptionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readModeSelectDescriptionCommandParams); - readModeSelectCommandInfo.put( - "readDescriptionAttribute", readModeSelectDescriptionAttributeCommandInfo); + readModeSelectInteractionInfo.put( + "readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); Map readModeSelectClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readModeSelectClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readModeSelectClusterRevisionCommandParams); - readModeSelectCommandInfo.put( - "readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("modeSelect").combineCommands(readModeSelectCommandInfo); - Map readNetworkCommissioningCommandInfo = new LinkedHashMap<>(); + readModeSelectInteractionInfo.put( + "readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); + Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); // read attribute Map readNetworkCommissioningFeatureMapCommandParams = new LinkedHashMap(); - CommandInfo readNetworkCommissioningFeatureMapAttributeCommandInfo = - new CommandInfo( + InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readNetworkCommissioningFeatureMapCommandParams); - readNetworkCommissioningCommandInfo.put( - "readFeatureMapAttribute", readNetworkCommissioningFeatureMapAttributeCommandInfo); + readNetworkCommissioningInteractionInfo.put( + "readFeatureMapAttribute", readNetworkCommissioningFeatureMapAttributeInteractionInfo); Map readNetworkCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readNetworkCommissioningClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readNetworkCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readNetworkCommissioningClusterRevisionCommandParams); - readNetworkCommissioningCommandInfo.put( + readNetworkCommissioningInteractionInfo.put( "readClusterRevisionAttribute", - readNetworkCommissioningClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("networkCommissioning").combineCommands(readNetworkCommissioningCommandInfo); - Map readOtaSoftwareUpdateProviderCommandInfo = new LinkedHashMap<>(); + readNetworkCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); + Map readOtaSoftwareUpdateProviderInteractionInfo = + new LinkedHashMap<>(); // read attribute Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOtaSoftwareUpdateProviderClusterRevisionCommandParams); - readOtaSoftwareUpdateProviderCommandInfo.put( + readOtaSoftwareUpdateProviderInteractionInfo.put( "readClusterRevisionAttribute", - readOtaSoftwareUpdateProviderClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap - .get("otaSoftwareUpdateProvider") - .combineCommands(readOtaSoftwareUpdateProviderCommandInfo); - Map readOtaSoftwareUpdateRequestorCommandInfo = new LinkedHashMap<>(); + readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); + Map readOtaSoftwareUpdateRequestorInteractionInfo = + new LinkedHashMap<>(); // read attribute Map readOtaSoftwareUpdateRequestorDefaultOtaProviderCommandParams = new LinkedHashMap(); - CommandInfo readOtaSoftwareUpdateRequestorDefaultOtaProviderAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOtaSoftwareUpdateRequestorDefaultOtaProviderAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) .readDefaultOtaProviderAttribute( @@ -10977,57 +11138,55 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedOctetStringAttributeCallback(), readOtaSoftwareUpdateRequestorDefaultOtaProviderCommandParams); - readOtaSoftwareUpdateRequestorCommandInfo.put( + readOtaSoftwareUpdateRequestorInteractionInfo.put( "readDefaultOtaProviderAttribute", - readOtaSoftwareUpdateRequestorDefaultOtaProviderAttributeCommandInfo); + readOtaSoftwareUpdateRequestorDefaultOtaProviderAttributeInteractionInfo); Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = new LinkedHashMap(); - CommandInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) .readUpdatePossibleAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams); - readOtaSoftwareUpdateRequestorCommandInfo.put( + readOtaSoftwareUpdateRequestorInteractionInfo.put( "readUpdatePossibleAttribute", - readOtaSoftwareUpdateRequestorUpdatePossibleAttributeCommandInfo); + readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo); Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOtaSoftwareUpdateRequestorClusterRevisionCommandParams); - readOtaSoftwareUpdateRequestorCommandInfo.put( + readOtaSoftwareUpdateRequestorInteractionInfo.put( "readClusterRevisionAttribute", - readOtaSoftwareUpdateRequestorClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap - .get("otaSoftwareUpdateRequestor") - .combineCommands(readOtaSoftwareUpdateRequestorCommandInfo); - Map readOccupancySensingCommandInfo = new LinkedHashMap<>(); + readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); + Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); // read attribute Map readOccupancySensingOccupancyCommandParams = new LinkedHashMap(); - CommandInfo readOccupancySensingOccupancyAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OccupancySensingCluster) cluster) .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOccupancySensingOccupancyCommandParams); - readOccupancySensingCommandInfo.put( - "readOccupancyAttribute", readOccupancySensingOccupancyAttributeCommandInfo); + readOccupancySensingInteractionInfo.put( + "readOccupancyAttribute", readOccupancySensingOccupancyAttributeInteractionInfo); Map readOccupancySensingOccupancySensorTypeCommandParams = new LinkedHashMap(); - CommandInfo readOccupancySensingOccupancySensorTypeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOccupancySensingOccupancySensorTypeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OccupancySensingCluster) cluster) .readOccupancySensorTypeAttribute( @@ -11035,13 +11194,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readOccupancySensingOccupancySensorTypeCommandParams); - readOccupancySensingCommandInfo.put( + readOccupancySensingInteractionInfo.put( "readOccupancySensorTypeAttribute", - readOccupancySensingOccupancySensorTypeAttributeCommandInfo); + readOccupancySensingOccupancySensorTypeAttributeInteractionInfo); Map readOccupancySensingOccupancySensorTypeBitmapCommandParams = new LinkedHashMap(); - CommandInfo readOccupancySensingOccupancySensorTypeBitmapAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OccupancySensingCluster) cluster) .readOccupancySensorTypeBitmapAttribute( @@ -11049,40 +11208,40 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readOccupancySensingOccupancySensorTypeBitmapCommandParams); - readOccupancySensingCommandInfo.put( + readOccupancySensingInteractionInfo.put( "readOccupancySensorTypeBitmapAttribute", - readOccupancySensingOccupancySensorTypeBitmapAttributeCommandInfo); + readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); Map readOccupancySensingClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readOccupancySensingClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OccupancySensingCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOccupancySensingClusterRevisionCommandParams); - readOccupancySensingCommandInfo.put( - "readClusterRevisionAttribute", readOccupancySensingClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("occupancySensing").combineCommands(readOccupancySensingCommandInfo); - Map readOnOffCommandInfo = new LinkedHashMap<>(); + readOccupancySensingInteractionInfo.put( + "readClusterRevisionAttribute", + readOccupancySensingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); + Map readOnOffInteractionInfo = new LinkedHashMap<>(); // read attribute Map readOnOffOnOffCommandParams = new LinkedHashMap(); - CommandInfo readOnOffOnOffAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffOnOffAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .readOnOffAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readOnOffOnOffCommandParams); - readOnOffCommandInfo.put("readOnOffAttribute", readOnOffOnOffAttributeCommandInfo); + readOnOffInteractionInfo.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); Map readOnOffGlobalSceneControlCommandParams = new LinkedHashMap(); - CommandInfo readOnOffGlobalSceneControlAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .readGlobalSceneControlAttribute( @@ -11090,117 +11249,116 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedBooleanAttributeCallback(), readOnOffGlobalSceneControlCommandParams); - readOnOffCommandInfo.put( - "readGlobalSceneControlAttribute", readOnOffGlobalSceneControlAttributeCommandInfo); + readOnOffInteractionInfo.put( + "readGlobalSceneControlAttribute", readOnOffGlobalSceneControlAttributeInteractionInfo); Map readOnOffOnTimeCommandParams = new LinkedHashMap(); - CommandInfo readOnOffOnTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffOnTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .readOnTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOnOffOnTimeCommandParams); - readOnOffCommandInfo.put("readOnTimeAttribute", readOnOffOnTimeAttributeCommandInfo); + readOnOffInteractionInfo.put("readOnTimeAttribute", readOnOffOnTimeAttributeInteractionInfo); Map readOnOffOffWaitTimeCommandParams = new LinkedHashMap(); - CommandInfo readOnOffOffWaitTimeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffOffWaitTimeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .readOffWaitTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOnOffOffWaitTimeCommandParams); - readOnOffCommandInfo.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeCommandInfo); + readOnOffInteractionInfo.put( + "readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); Map readOnOffStartUpOnOffCommandParams = new LinkedHashMap(); - CommandInfo readOnOffStartUpOnOffAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .readStartUpOnOffAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOnOffStartUpOnOffCommandParams); - readOnOffCommandInfo.put( - "readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeCommandInfo); + readOnOffInteractionInfo.put( + "readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); Map readOnOffFeatureMapCommandParams = new LinkedHashMap(); - CommandInfo readOnOffFeatureMapAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readOnOffFeatureMapCommandParams); - readOnOffCommandInfo.put("readFeatureMapAttribute", readOnOffFeatureMapAttributeCommandInfo); + readOnOffInteractionInfo.put( + "readFeatureMapAttribute", readOnOffFeatureMapAttributeInteractionInfo); Map readOnOffClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readOnOffClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOnOffClusterRevisionCommandParams); - readOnOffCommandInfo.put( - "readClusterRevisionAttribute", readOnOffClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("onOff").combineCommands(readOnOffCommandInfo); - Map readOnOffSwitchConfigurationCommandInfo = new LinkedHashMap<>(); + readOnOffInteractionInfo.put( + "readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOff", readOnOffInteractionInfo); + Map readOnOffSwitchConfigurationInteractionInfo = + new LinkedHashMap<>(); // read attribute Map readOnOffSwitchConfigurationSwitchTypeCommandParams = new LinkedHashMap(); - CommandInfo readOnOffSwitchConfigurationSwitchTypeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) .readSwitchTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOnOffSwitchConfigurationSwitchTypeCommandParams); - readOnOffSwitchConfigurationCommandInfo.put( - "readSwitchTypeAttribute", readOnOffSwitchConfigurationSwitchTypeAttributeCommandInfo); + readOnOffSwitchConfigurationInteractionInfo.put( + "readSwitchTypeAttribute", readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo); Map readOnOffSwitchConfigurationSwitchActionsCommandParams = new LinkedHashMap(); - CommandInfo readOnOffSwitchConfigurationSwitchActionsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) .readSwitchActionsAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOnOffSwitchConfigurationSwitchActionsCommandParams); - readOnOffSwitchConfigurationCommandInfo.put( + readOnOffSwitchConfigurationInteractionInfo.put( "readSwitchActionsAttribute", - readOnOffSwitchConfigurationSwitchActionsAttributeCommandInfo); + readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); Map readOnOffSwitchConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readOnOffSwitchConfigurationClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOnOffSwitchConfigurationClusterRevisionCommandParams); - readOnOffSwitchConfigurationCommandInfo.put( + readOnOffSwitchConfigurationInteractionInfo.put( "readClusterRevisionAttribute", - readOnOffSwitchConfigurationClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap - .get("onOffSwitchConfiguration") - .combineCommands(readOnOffSwitchConfigurationCommandInfo); - Map readOperationalCredentialsCommandInfo = new LinkedHashMap<>(); + readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); + Map readOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); // read attribute Map readOperationalCredentialsFabricsListCommandParams = new LinkedHashMap(); - CommandInfo readOperationalCredentialsFabricsListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .readFabricsListAttribute( @@ -11209,25 +11367,25 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedFabricsListAttributeCallback(), readOperationalCredentialsFabricsListCommandParams); - readOperationalCredentialsCommandInfo.put( - "readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeCommandInfo); + readOperationalCredentialsInteractionInfo.put( + "readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); Map readOperationalCredentialsSupportedFabricsCommandParams = new LinkedHashMap(); - CommandInfo readOperationalCredentialsSupportedFabricsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .readSupportedFabricsAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOperationalCredentialsSupportedFabricsCommandParams); - readOperationalCredentialsCommandInfo.put( + readOperationalCredentialsInteractionInfo.put( "readSupportedFabricsAttribute", - readOperationalCredentialsSupportedFabricsAttributeCommandInfo); + readOperationalCredentialsSupportedFabricsAttributeInteractionInfo); Map readOperationalCredentialsCommissionedFabricsCommandParams = new LinkedHashMap(); - CommandInfo readOperationalCredentialsCommissionedFabricsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .readCommissionedFabricsAttribute( @@ -11235,14 +11393,14 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readOperationalCredentialsCommissionedFabricsCommandParams); - readOperationalCredentialsCommandInfo.put( + readOperationalCredentialsInteractionInfo.put( "readCommissionedFabricsAttribute", - readOperationalCredentialsCommissionedFabricsAttributeCommandInfo); + readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo); Map readOperationalCredentialsTrustedRootCertificatesCommandParams = new LinkedHashMap(); - CommandInfo readOperationalCredentialsTrustedRootCertificatesAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .readTrustedRootCertificatesAttribute( @@ -11252,13 +11410,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedTrustedRootCertificatesAttributeCallback(), readOperationalCredentialsTrustedRootCertificatesCommandParams); - readOperationalCredentialsCommandInfo.put( + readOperationalCredentialsInteractionInfo.put( "readTrustedRootCertificatesAttribute", - readOperationalCredentialsTrustedRootCertificatesAttributeCommandInfo); + readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); Map readOperationalCredentialsCurrentFabricIndexCommandParams = new LinkedHashMap(); - CommandInfo readOperationalCredentialsCurrentFabricIndexAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .readCurrentFabricIndexAttribute( @@ -11266,77 +11424,77 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readOperationalCredentialsCurrentFabricIndexCommandParams); - readOperationalCredentialsCommandInfo.put( + readOperationalCredentialsInteractionInfo.put( "readCurrentFabricIndexAttribute", - readOperationalCredentialsCurrentFabricIndexAttributeCommandInfo); + readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); Map readOperationalCredentialsClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readOperationalCredentialsClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readOperationalCredentialsClusterRevisionCommandParams); - readOperationalCredentialsCommandInfo.put( + readOperationalCredentialsInteractionInfo.put( "readClusterRevisionAttribute", - readOperationalCredentialsClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("operationalCredentials").combineCommands(readOperationalCredentialsCommandInfo); - Map readPowerSourceCommandInfo = new LinkedHashMap<>(); + readOperationalCredentialsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); + Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); // read attribute Map readPowerSourceStatusCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceStatusAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceStatusAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPowerSourceStatusCommandParams); - readPowerSourceCommandInfo.put( - "readStatusAttribute", readPowerSourceStatusAttributeCommandInfo); + readPowerSourceInteractionInfo.put( + "readStatusAttribute", readPowerSourceStatusAttributeInteractionInfo); Map readPowerSourceOrderCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceOrderAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceOrderAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readOrderAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPowerSourceOrderCommandParams); - readPowerSourceCommandInfo.put("readOrderAttribute", readPowerSourceOrderAttributeCommandInfo); + readPowerSourceInteractionInfo.put( + "readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); Map readPowerSourceDescriptionCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceDescriptionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readPowerSourceDescriptionCommandParams); - readPowerSourceCommandInfo.put( - "readDescriptionAttribute", readPowerSourceDescriptionAttributeCommandInfo); + readPowerSourceInteractionInfo.put( + "readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); Map readPowerSourceBatteryVoltageCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceBatteryVoltageAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readBatteryVoltageAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readPowerSourceBatteryVoltageCommandParams); - readPowerSourceCommandInfo.put( - "readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeCommandInfo); + readPowerSourceInteractionInfo.put( + "readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); Map readPowerSourceBatteryPercentRemainingCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceBatteryPercentRemainingAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readBatteryPercentRemainingAttribute( @@ -11344,26 +11502,26 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readPowerSourceBatteryPercentRemainingCommandParams); - readPowerSourceCommandInfo.put( + readPowerSourceInteractionInfo.put( "readBatteryPercentRemainingAttribute", - readPowerSourceBatteryPercentRemainingAttributeCommandInfo); + readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); Map readPowerSourceBatteryTimeRemainingCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceBatteryTimeRemainingAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readBatteryTimeRemainingAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readPowerSourceBatteryTimeRemainingCommandParams); - readPowerSourceCommandInfo.put( + readPowerSourceInteractionInfo.put( "readBatteryTimeRemainingAttribute", - readPowerSourceBatteryTimeRemainingAttributeCommandInfo); + readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); Map readPowerSourceBatteryChargeLevelCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceBatteryChargeLevelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readBatteryChargeLevelAttribute( @@ -11371,12 +11529,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readPowerSourceBatteryChargeLevelCommandParams); - readPowerSourceCommandInfo.put( - "readBatteryChargeLevelAttribute", readPowerSourceBatteryChargeLevelAttributeCommandInfo); + readPowerSourceInteractionInfo.put( + "readBatteryChargeLevelAttribute", + readPowerSourceBatteryChargeLevelAttributeInteractionInfo); Map readPowerSourceActiveBatteryFaultsCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceActiveBatteryFaultsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readActiveBatteryFaultsAttribute( @@ -11385,12 +11544,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedActiveBatteryFaultsAttributeCallback(), readPowerSourceActiveBatteryFaultsCommandParams); - readPowerSourceCommandInfo.put( - "readActiveBatteryFaultsAttribute", readPowerSourceActiveBatteryFaultsAttributeCommandInfo); + readPowerSourceInteractionInfo.put( + "readActiveBatteryFaultsAttribute", + readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); Map readPowerSourceBatteryChargeStateCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceBatteryChargeStateAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readBatteryChargeStateAttribute( @@ -11398,273 +11558,276 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readPowerSourceBatteryChargeStateCommandParams); - readPowerSourceCommandInfo.put( - "readBatteryChargeStateAttribute", readPowerSourceBatteryChargeStateAttributeCommandInfo); + readPowerSourceInteractionInfo.put( + "readBatteryChargeStateAttribute", + readPowerSourceBatteryChargeStateAttributeInteractionInfo); Map readPowerSourceFeatureMapCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceFeatureMapAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readPowerSourceFeatureMapCommandParams); - readPowerSourceCommandInfo.put( - "readFeatureMapAttribute", readPowerSourceFeatureMapAttributeCommandInfo); + readPowerSourceInteractionInfo.put( + "readFeatureMapAttribute", readPowerSourceFeatureMapAttributeInteractionInfo); Map readPowerSourceClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readPowerSourceClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPowerSourceClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PowerSourceCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPowerSourceClusterRevisionCommandParams); - readPowerSourceCommandInfo.put( - "readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("powerSource").combineCommands(readPowerSourceCommandInfo); - Map readPressureMeasurementCommandInfo = new LinkedHashMap<>(); + readPowerSourceInteractionInfo.put( + "readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); + Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); // read attribute Map readPressureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readPressureMeasurementMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PressureMeasurementCluster) cluster) .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPressureMeasurementMeasuredValueCommandParams); - readPressureMeasurementCommandInfo.put( - "readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeCommandInfo); + readPressureMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); Map readPressureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readPressureMeasurementMinMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PressureMeasurementCluster) cluster) .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPressureMeasurementMinMeasuredValueCommandParams); - readPressureMeasurementCommandInfo.put( + readPressureMeasurementInteractionInfo.put( "readMinMeasuredValueAttribute", - readPressureMeasurementMinMeasuredValueAttributeCommandInfo); + readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); Map readPressureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readPressureMeasurementMaxMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PressureMeasurementCluster) cluster) .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPressureMeasurementMaxMeasuredValueCommandParams); - readPressureMeasurementCommandInfo.put( + readPressureMeasurementInteractionInfo.put( "readMaxMeasuredValueAttribute", - readPressureMeasurementMaxMeasuredValueAttributeCommandInfo); + readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); Map readPressureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readPressureMeasurementClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PressureMeasurementCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPressureMeasurementClusterRevisionCommandParams); - readPressureMeasurementCommandInfo.put( - "readClusterRevisionAttribute", readPressureMeasurementClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("pressureMeasurement").combineCommands(readPressureMeasurementCommandInfo); - Map readPumpConfigurationAndControlCommandInfo = new LinkedHashMap<>(); + readPressureMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readPressureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); + Map readPumpConfigurationAndControlInteractionInfo = + new LinkedHashMap<>(); // read attribute Map readPumpConfigurationAndControlMaxPressureCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMaxPressureAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMaxPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMaxPressureCommandParams); - readPumpConfigurationAndControlCommandInfo.put( - "readMaxPressureAttribute", readPumpConfigurationAndControlMaxPressureAttributeCommandInfo); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxPressureAttribute", + readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); Map readPumpConfigurationAndControlMaxSpeedCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMaxSpeedAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMaxSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMaxSpeedCommandParams); - readPumpConfigurationAndControlCommandInfo.put( - "readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeCommandInfo); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); Map readPumpConfigurationAndControlMaxFlowCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMaxFlowAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMaxFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMaxFlowCommandParams); - readPumpConfigurationAndControlCommandInfo.put( - "readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeCommandInfo); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); Map readPumpConfigurationAndControlMinConstPressureCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMinConstPressureAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMinConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMinConstPressureCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMinConstPressureAttribute", - readPumpConfigurationAndControlMinConstPressureAttributeCommandInfo); + readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); Map readPumpConfigurationAndControlMaxConstPressureCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMaxConstPressureAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMaxConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMaxConstPressureCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMaxConstPressureAttribute", - readPumpConfigurationAndControlMaxConstPressureAttributeCommandInfo); + readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); Map readPumpConfigurationAndControlMinCompPressureCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMinCompPressureAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMinCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMinCompPressureCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMinCompPressureAttribute", - readPumpConfigurationAndControlMinCompPressureAttributeCommandInfo); + readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); Map readPumpConfigurationAndControlMaxCompPressureCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMaxCompPressureAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMaxCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMaxCompPressureCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMaxCompPressureAttribute", - readPumpConfigurationAndControlMaxCompPressureAttributeCommandInfo); + readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); Map readPumpConfigurationAndControlMinConstSpeedCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMinConstSpeedAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMinConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMinConstSpeedCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMinConstSpeedAttribute", - readPumpConfigurationAndControlMinConstSpeedAttributeCommandInfo); + readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMaxConstSpeedAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMaxConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMaxConstSpeedCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMaxConstSpeedAttribute", - readPumpConfigurationAndControlMaxConstSpeedAttributeCommandInfo); + readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); Map readPumpConfigurationAndControlMinConstFlowCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMinConstFlowAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMinConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMinConstFlowCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMinConstFlowAttribute", - readPumpConfigurationAndControlMinConstFlowAttributeCommandInfo); + readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); Map readPumpConfigurationAndControlMaxConstFlowCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMaxConstFlowAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMaxConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMaxConstFlowCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMaxConstFlowAttribute", - readPumpConfigurationAndControlMaxConstFlowAttributeCommandInfo); + readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); Map readPumpConfigurationAndControlMinConstTempCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMinConstTempAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMinConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMinConstTempCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMinConstTempAttribute", - readPumpConfigurationAndControlMinConstTempAttributeCommandInfo); + readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); Map readPumpConfigurationAndControlMaxConstTempCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlMaxConstTempAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readMaxConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlMaxConstTempCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readMaxConstTempAttribute", - readPumpConfigurationAndControlMaxConstTempAttributeCommandInfo); + readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo); Map readPumpConfigurationAndControlPumpStatusCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlPumpStatusAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readPumpStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlPumpStatusCommandParams); - readPumpConfigurationAndControlCommandInfo.put( - "readPumpStatusAttribute", readPumpConfigurationAndControlPumpStatusAttributeCommandInfo); + readPumpConfigurationAndControlInteractionInfo.put( + "readPumpStatusAttribute", + readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo); Map readPumpConfigurationAndControlEffectiveOperationModeCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlEffectiveOperationModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readEffectiveOperationModeAttribute( @@ -11672,14 +11835,14 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlEffectiveOperationModeCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readEffectiveOperationModeAttribute", - readPumpConfigurationAndControlEffectiveOperationModeAttributeCommandInfo); + readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo); Map readPumpConfigurationAndControlEffectiveControlModeCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlEffectiveControlModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readEffectiveControlModeAttribute( @@ -11687,38 +11850,38 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlEffectiveControlModeCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readEffectiveControlModeAttribute", - readPumpConfigurationAndControlEffectiveControlModeAttributeCommandInfo); + readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); Map readPumpConfigurationAndControlCapacityCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlCapacityAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readCapacityAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlCapacityCommandParams); - readPumpConfigurationAndControlCommandInfo.put( - "readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeCommandInfo); + readPumpConfigurationAndControlInteractionInfo.put( + "readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); Map readPumpConfigurationAndControlSpeedCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlSpeedAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlSpeedCommandParams); - readPumpConfigurationAndControlCommandInfo.put( - "readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeCommandInfo); + readPumpConfigurationAndControlInteractionInfo.put( + "readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); Map readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readLifetimeEnergyConsumedAttribute( @@ -11726,225 +11889,225 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readLifetimeEnergyConsumedAttribute", - readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCommandInfo); + readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo); Map readPumpConfigurationAndControlOperationModeCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlOperationModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlOperationModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readOperationModeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlOperationModeCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readOperationModeAttribute", - readPumpConfigurationAndControlOperationModeAttributeCommandInfo); + readPumpConfigurationAndControlOperationModeAttributeInteractionInfo); Map readPumpConfigurationAndControlControlModeCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlControlModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlControlModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readControlModeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlControlModeCommandParams); - readPumpConfigurationAndControlCommandInfo.put( - "readControlModeAttribute", readPumpConfigurationAndControlControlModeAttributeCommandInfo); + readPumpConfigurationAndControlInteractionInfo.put( + "readControlModeAttribute", + readPumpConfigurationAndControlControlModeAttributeInteractionInfo); Map readPumpConfigurationAndControlAlarmMaskCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlAlarmMaskAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readAlarmMaskAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlAlarmMaskCommandParams); - readPumpConfigurationAndControlCommandInfo.put( - "readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeCommandInfo); + readPumpConfigurationAndControlInteractionInfo.put( + "readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); Map readPumpConfigurationAndControlFeatureMapCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlFeatureMapAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readPumpConfigurationAndControlFeatureMapCommandParams); - readPumpConfigurationAndControlCommandInfo.put( - "readFeatureMapAttribute", readPumpConfigurationAndControlFeatureMapAttributeCommandInfo); + readPumpConfigurationAndControlInteractionInfo.put( + "readFeatureMapAttribute", + readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo); Map readPumpConfigurationAndControlClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readPumpConfigurationAndControlClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.PumpConfigurationAndControlCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readPumpConfigurationAndControlClusterRevisionCommandParams); - readPumpConfigurationAndControlCommandInfo.put( + readPumpConfigurationAndControlInteractionInfo.put( "readClusterRevisionAttribute", - readPumpConfigurationAndControlClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap - .get("pumpConfigurationAndControl") - .combineCommands(readPumpConfigurationAndControlCommandInfo); - Map readRelativeHumidityMeasurementCommandInfo = new LinkedHashMap<>(); + readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); + Map readRelativeHumidityMeasurementInteractionInfo = + new LinkedHashMap<>(); // read attribute Map readRelativeHumidityMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readRelativeHumidityMeasurementMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readRelativeHumidityMeasurementMeasuredValueCommandParams); - readRelativeHumidityMeasurementCommandInfo.put( + readRelativeHumidityMeasurementInteractionInfo.put( "readMeasuredValueAttribute", - readRelativeHumidityMeasurementMeasuredValueAttributeCommandInfo); + readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readRelativeHumidityMeasurementMinMeasuredValueCommandParams); - readRelativeHumidityMeasurementCommandInfo.put( + readRelativeHumidityMeasurementInteractionInfo.put( "readMinMeasuredValueAttribute", - readRelativeHumidityMeasurementMinMeasuredValueAttributeCommandInfo); + readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readRelativeHumidityMeasurementMaxMeasuredValueCommandParams); - readRelativeHumidityMeasurementCommandInfo.put( + readRelativeHumidityMeasurementInteractionInfo.put( "readMaxMeasuredValueAttribute", - readRelativeHumidityMeasurementMaxMeasuredValueAttributeCommandInfo); + readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo); Map readRelativeHumidityMeasurementToleranceCommandParams = new LinkedHashMap(); - CommandInfo readRelativeHumidityMeasurementToleranceAttributeCommandInfo = - new CommandInfo( + InteractionInfo readRelativeHumidityMeasurementToleranceAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readRelativeHumidityMeasurementToleranceCommandParams); - readRelativeHumidityMeasurementCommandInfo.put( - "readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeCommandInfo); + readRelativeHumidityMeasurementInteractionInfo.put( + "readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); Map readRelativeHumidityMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readRelativeHumidityMeasurementClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readRelativeHumidityMeasurementClusterRevisionCommandParams); - readRelativeHumidityMeasurementCommandInfo.put( + readRelativeHumidityMeasurementInteractionInfo.put( "readClusterRevisionAttribute", - readRelativeHumidityMeasurementClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap - .get("relativeHumidityMeasurement") - .combineCommands(readRelativeHumidityMeasurementCommandInfo); - Map readScenesCommandInfo = new LinkedHashMap<>(); + readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); + Map readScenesInteractionInfo = new LinkedHashMap<>(); // read attribute Map readScenesSceneCountCommandParams = new LinkedHashMap(); - CommandInfo readScenesSceneCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readScenesSceneCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .readSceneCountAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readScenesSceneCountCommandParams); - readScenesCommandInfo.put("readSceneCountAttribute", readScenesSceneCountAttributeCommandInfo); + readScenesInteractionInfo.put( + "readSceneCountAttribute", readScenesSceneCountAttributeInteractionInfo); Map readScenesCurrentSceneCommandParams = new LinkedHashMap(); - CommandInfo readScenesCurrentSceneAttributeCommandInfo = - new CommandInfo( + InteractionInfo readScenesCurrentSceneAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .readCurrentSceneAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readScenesCurrentSceneCommandParams); - readScenesCommandInfo.put( - "readCurrentSceneAttribute", readScenesCurrentSceneAttributeCommandInfo); + readScenesInteractionInfo.put( + "readCurrentSceneAttribute", readScenesCurrentSceneAttributeInteractionInfo); Map readScenesCurrentGroupCommandParams = new LinkedHashMap(); - CommandInfo readScenesCurrentGroupAttributeCommandInfo = - new CommandInfo( + InteractionInfo readScenesCurrentGroupAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .readCurrentGroupAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readScenesCurrentGroupCommandParams); - readScenesCommandInfo.put( - "readCurrentGroupAttribute", readScenesCurrentGroupAttributeCommandInfo); + readScenesInteractionInfo.put( + "readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); Map readScenesSceneValidCommandParams = new LinkedHashMap(); - CommandInfo readScenesSceneValidAttributeCommandInfo = - new CommandInfo( + InteractionInfo readScenesSceneValidAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .readSceneValidAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readScenesSceneValidCommandParams); - readScenesCommandInfo.put("readSceneValidAttribute", readScenesSceneValidAttributeCommandInfo); + readScenesInteractionInfo.put( + "readSceneValidAttribute", readScenesSceneValidAttributeInteractionInfo); Map readScenesNameSupportCommandParams = new LinkedHashMap(); - CommandInfo readScenesNameSupportAttributeCommandInfo = - new CommandInfo( + InteractionInfo readScenesNameSupportAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readScenesNameSupportCommandParams); - readScenesCommandInfo.put( - "readNameSupportAttribute", readScenesNameSupportAttributeCommandInfo); + readScenesInteractionInfo.put( + "readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); Map readScenesClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readScenesClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readScenesClusterRevisionCommandParams); - readScenesCommandInfo.put( - "readClusterRevisionAttribute", readScenesClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("scenes").combineCommands(readScenesCommandInfo); - Map readSoftwareDiagnosticsCommandInfo = new LinkedHashMap<>(); + readScenesInteractionInfo.put( + "readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("scenes", readScenesInteractionInfo); + Map readSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); // read attribute Map readSoftwareDiagnosticsThreadMetricsCommandParams = new LinkedHashMap(); - CommandInfo readSoftwareDiagnosticsThreadMetricsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SoftwareDiagnosticsCluster) cluster) .readThreadMetricsAttribute( @@ -11953,36 +12116,38 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedThreadMetricsAttributeCallback(), readSoftwareDiagnosticsThreadMetricsCommandParams); - readSoftwareDiagnosticsCommandInfo.put( - "readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeCommandInfo); + readSoftwareDiagnosticsInteractionInfo.put( + "readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = new LinkedHashMap(); - CommandInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SoftwareDiagnosticsCluster) cluster) .readCurrentHeapFreeAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readSoftwareDiagnosticsCurrentHeapFreeCommandParams); - readSoftwareDiagnosticsCommandInfo.put( - "readCurrentHeapFreeAttribute", readSoftwareDiagnosticsCurrentHeapFreeAttributeCommandInfo); + readSoftwareDiagnosticsInteractionInfo.put( + "readCurrentHeapFreeAttribute", + readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = new LinkedHashMap(); - CommandInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SoftwareDiagnosticsCluster) cluster) .readCurrentHeapUsedAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readSoftwareDiagnosticsCurrentHeapUsedCommandParams); - readSoftwareDiagnosticsCommandInfo.put( - "readCurrentHeapUsedAttribute", readSoftwareDiagnosticsCurrentHeapUsedAttributeCommandInfo); + readSoftwareDiagnosticsInteractionInfo.put( + "readCurrentHeapUsedAttribute", + readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = new LinkedHashMap(); - CommandInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SoftwareDiagnosticsCluster) cluster) .readCurrentHeapHighWatermarkAttribute( @@ -11990,92 +12155,92 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams); - readSoftwareDiagnosticsCommandInfo.put( + readSoftwareDiagnosticsInteractionInfo.put( "readCurrentHeapHighWatermarkAttribute", - readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeCommandInfo); + readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); Map readSoftwareDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readSoftwareDiagnosticsClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SoftwareDiagnosticsCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readSoftwareDiagnosticsClusterRevisionCommandParams); - readSoftwareDiagnosticsCommandInfo.put( - "readClusterRevisionAttribute", readSoftwareDiagnosticsClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("softwareDiagnostics").combineCommands(readSoftwareDiagnosticsCommandInfo); - Map readSwitchCommandInfo = new LinkedHashMap<>(); + readSoftwareDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); + Map readSwitchInteractionInfo = new LinkedHashMap<>(); // read attribute Map readSwitchNumberOfPositionsCommandParams = new LinkedHashMap(); - CommandInfo readSwitchNumberOfPositionsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SwitchCluster) cluster) .readNumberOfPositionsAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readSwitchNumberOfPositionsCommandParams); - readSwitchCommandInfo.put( - "readNumberOfPositionsAttribute", readSwitchNumberOfPositionsAttributeCommandInfo); + readSwitchInteractionInfo.put( + "readNumberOfPositionsAttribute", readSwitchNumberOfPositionsAttributeInteractionInfo); Map readSwitchCurrentPositionCommandParams = new LinkedHashMap(); - CommandInfo readSwitchCurrentPositionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSwitchCurrentPositionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SwitchCluster) cluster) .readCurrentPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readSwitchCurrentPositionCommandParams); - readSwitchCommandInfo.put( - "readCurrentPositionAttribute", readSwitchCurrentPositionAttributeCommandInfo); + readSwitchInteractionInfo.put( + "readCurrentPositionAttribute", readSwitchCurrentPositionAttributeInteractionInfo); Map readSwitchMultiPressMaxCommandParams = new LinkedHashMap(); - CommandInfo readSwitchMultiPressMaxAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSwitchMultiPressMaxAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SwitchCluster) cluster) .readMultiPressMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readSwitchMultiPressMaxCommandParams); - readSwitchCommandInfo.put( - "readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeCommandInfo); + readSwitchInteractionInfo.put( + "readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); Map readSwitchFeatureMapCommandParams = new LinkedHashMap(); - CommandInfo readSwitchFeatureMapAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SwitchCluster) cluster) .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readSwitchFeatureMapCommandParams); - readSwitchCommandInfo.put("readFeatureMapAttribute", readSwitchFeatureMapAttributeCommandInfo); + readSwitchInteractionInfo.put( + "readFeatureMapAttribute", readSwitchFeatureMapAttributeInteractionInfo); Map readSwitchClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readSwitchClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readSwitchClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.SwitchCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readSwitchClusterRevisionCommandParams); - readSwitchCommandInfo.put( - "readClusterRevisionAttribute", readSwitchClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("switch").combineCommands(readSwitchCommandInfo); - Map readTvChannelCommandInfo = new LinkedHashMap<>(); + readSwitchInteractionInfo.put( + "readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("switch", readSwitchInteractionInfo); + Map readTvChannelInteractionInfo = new LinkedHashMap<>(); // read attribute Map readTvChannelTvChannelListCommandParams = new LinkedHashMap(); - CommandInfo readTvChannelTvChannelListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTvChannelTvChannelListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TvChannelCluster) cluster) .readTvChannelListAttribute( @@ -12083,12 +12248,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedTvChannelListAttributeCallback(), readTvChannelTvChannelListCommandParams); - readTvChannelCommandInfo.put( - "readTvChannelListAttribute", readTvChannelTvChannelListAttributeCommandInfo); + readTvChannelInteractionInfo.put( + "readTvChannelListAttribute", readTvChannelTvChannelListAttributeInteractionInfo); Map readTvChannelTvChannelLineupCommandParams = new LinkedHashMap(); - CommandInfo readTvChannelTvChannelLineupAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTvChannelTvChannelLineupAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TvChannelCluster) cluster) .readTvChannelLineupAttribute( @@ -12096,12 +12261,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedOctetStringAttributeCallback(), readTvChannelTvChannelLineupCommandParams); - readTvChannelCommandInfo.put( - "readTvChannelLineupAttribute", readTvChannelTvChannelLineupAttributeCommandInfo); + readTvChannelInteractionInfo.put( + "readTvChannelLineupAttribute", readTvChannelTvChannelLineupAttributeInteractionInfo); Map readTvChannelCurrentTvChannelCommandParams = new LinkedHashMap(); - CommandInfo readTvChannelCurrentTvChannelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTvChannelCurrentTvChannelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TvChannelCluster) cluster) .readCurrentTvChannelAttribute( @@ -12109,28 +12274,27 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedOctetStringAttributeCallback(), readTvChannelCurrentTvChannelCommandParams); - readTvChannelCommandInfo.put( - "readCurrentTvChannelAttribute", readTvChannelCurrentTvChannelAttributeCommandInfo); + readTvChannelInteractionInfo.put( + "readCurrentTvChannelAttribute", readTvChannelCurrentTvChannelAttributeInteractionInfo); Map readTvChannelClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readTvChannelClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTvChannelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TvChannelCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTvChannelClusterRevisionCommandParams); - readTvChannelCommandInfo.put( - "readClusterRevisionAttribute", readTvChannelClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("tvChannel").combineCommands(readTvChannelCommandInfo); - Map readTargetNavigatorCommandInfo = new LinkedHashMap<>(); + readTvChannelInteractionInfo.put( + "readClusterRevisionAttribute", readTvChannelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("tvChannel", readTvChannelInteractionInfo); + Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); // read attribute Map readTargetNavigatorTargetNavigatorListCommandParams = new LinkedHashMap(); - CommandInfo readTargetNavigatorTargetNavigatorListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TargetNavigatorCluster) cluster) .readTargetNavigatorListAttribute( @@ -12139,285 +12303,287 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedTargetNavigatorListAttributeCallback(), readTargetNavigatorTargetNavigatorListCommandParams); - readTargetNavigatorCommandInfo.put( + readTargetNavigatorInteractionInfo.put( "readTargetNavigatorListAttribute", - readTargetNavigatorTargetNavigatorListAttributeCommandInfo); + readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); Map readTargetNavigatorClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readTargetNavigatorClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TargetNavigatorCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTargetNavigatorClusterRevisionCommandParams); - readTargetNavigatorCommandInfo.put( - "readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("targetNavigator").combineCommands(readTargetNavigatorCommandInfo); - Map readTemperatureMeasurementCommandInfo = new LinkedHashMap<>(); + readTargetNavigatorInteractionInfo.put( + "readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); + Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); // read attribute Map readTemperatureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readTemperatureMeasurementMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TemperatureMeasurementCluster) cluster) .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTemperatureMeasurementMeasuredValueCommandParams); - readTemperatureMeasurementCommandInfo.put( - "readMeasuredValueAttribute", readTemperatureMeasurementMeasuredValueAttributeCommandInfo); + readTemperatureMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); Map readTemperatureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readTemperatureMeasurementMinMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TemperatureMeasurementCluster) cluster) .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTemperatureMeasurementMinMeasuredValueCommandParams); - readTemperatureMeasurementCommandInfo.put( + readTemperatureMeasurementInteractionInfo.put( "readMinMeasuredValueAttribute", - readTemperatureMeasurementMinMeasuredValueAttributeCommandInfo); + readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); Map readTemperatureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - CommandInfo readTemperatureMeasurementMaxMeasuredValueAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TemperatureMeasurementCluster) cluster) .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTemperatureMeasurementMaxMeasuredValueCommandParams); - readTemperatureMeasurementCommandInfo.put( + readTemperatureMeasurementInteractionInfo.put( "readMaxMeasuredValueAttribute", - readTemperatureMeasurementMaxMeasuredValueAttributeCommandInfo); + readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo); Map readTemperatureMeasurementToleranceCommandParams = new LinkedHashMap(); - CommandInfo readTemperatureMeasurementToleranceAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTemperatureMeasurementToleranceAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TemperatureMeasurementCluster) cluster) .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTemperatureMeasurementToleranceCommandParams); - readTemperatureMeasurementCommandInfo.put( - "readToleranceAttribute", readTemperatureMeasurementToleranceAttributeCommandInfo); + readTemperatureMeasurementInteractionInfo.put( + "readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); Map readTemperatureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readTemperatureMeasurementClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TemperatureMeasurementCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTemperatureMeasurementClusterRevisionCommandParams); - readTemperatureMeasurementCommandInfo.put( + readTemperatureMeasurementInteractionInfo.put( "readClusterRevisionAttribute", - readTemperatureMeasurementClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("temperatureMeasurement").combineCommands(readTemperatureMeasurementCommandInfo); - Map readTestClusterCommandInfo = new LinkedHashMap<>(); + readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); + Map readTestClusterInteractionInfo = new LinkedHashMap<>(); // read attribute Map readTestClusterBooleanCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterBooleanAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterBooleanAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readTestClusterBooleanCommandParams); - readTestClusterCommandInfo.put( - "readBooleanAttribute", readTestClusterBooleanAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); Map readTestClusterBitmap8CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterBitmap8AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readBitmap8Attribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterBitmap8CommandParams); - readTestClusterCommandInfo.put( - "readBitmap8Attribute", readTestClusterBitmap8AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); Map readTestClusterBitmap16CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterBitmap16AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readBitmap16Attribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterBitmap16CommandParams); - readTestClusterCommandInfo.put( - "readBitmap16Attribute", readTestClusterBitmap16AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); Map readTestClusterBitmap32CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterBitmap32AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readBitmap32Attribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterBitmap32CommandParams); - readTestClusterCommandInfo.put( - "readBitmap32Attribute", readTestClusterBitmap32AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); Map readTestClusterBitmap64CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterBitmap64AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readBitmap64Attribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterBitmap64CommandParams); - readTestClusterCommandInfo.put( - "readBitmap64Attribute", readTestClusterBitmap64AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); Map readTestClusterInt8uCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterInt8uAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterInt8uAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterInt8uCommandParams); - readTestClusterCommandInfo.put("readInt8uAttribute", readTestClusterInt8uAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); Map readTestClusterInt16uCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterInt16uAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterInt16uAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readInt16uAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterInt16uCommandParams); - readTestClusterCommandInfo.put( - "readInt16uAttribute", readTestClusterInt16uAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); Map readTestClusterInt32uCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterInt32uAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterInt32uAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readInt32uAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterInt32uCommandParams); - readTestClusterCommandInfo.put( - "readInt32uAttribute", readTestClusterInt32uAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); Map readTestClusterInt64uCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterInt64uAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterInt64uAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readInt64uAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterInt64uCommandParams); - readTestClusterCommandInfo.put( - "readInt64uAttribute", readTestClusterInt64uAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); Map readTestClusterInt8sCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterInt8sAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterInt8sAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readInt8sAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterInt8sCommandParams); - readTestClusterCommandInfo.put("readInt8sAttribute", readTestClusterInt8sAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); Map readTestClusterInt16sCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterInt16sAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterInt16sAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readInt16sAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterInt16sCommandParams); - readTestClusterCommandInfo.put( - "readInt16sAttribute", readTestClusterInt16sAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); Map readTestClusterInt32sCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterInt32sAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterInt32sAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readInt32sAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterInt32sCommandParams); - readTestClusterCommandInfo.put( - "readInt32sAttribute", readTestClusterInt32sAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); Map readTestClusterInt64sCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterInt64sAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterInt64sAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readInt64sAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterInt64sCommandParams); - readTestClusterCommandInfo.put( - "readInt64sAttribute", readTestClusterInt64sAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); Map readTestClusterEnum8CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterEnum8AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterEnum8AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readEnum8Attribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterEnum8CommandParams); - readTestClusterCommandInfo.put("readEnum8Attribute", readTestClusterEnum8AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); Map readTestClusterEnum16CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterEnum16AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterEnum16AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readEnum16Attribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterEnum16CommandParams); - readTestClusterCommandInfo.put( - "readEnum16Attribute", readTestClusterEnum16AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); Map readTestClusterOctetStringCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterOctetStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readOctetStringAttribute((ChipClusters.OctetStringAttributeCallback) callback); }, () -> new DelegatedOctetStringAttributeCallback(), readTestClusterOctetStringCommandParams); - readTestClusterCommandInfo.put( - "readOctetStringAttribute", readTestClusterOctetStringAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); Map readTestClusterListInt8uCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterListInt8uAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readListInt8uAttribute( @@ -12425,12 +12591,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedListInt8uAttributeCallback(), readTestClusterListInt8uCommandParams); - readTestClusterCommandInfo.put( - "readListInt8uAttribute", readTestClusterListInt8uAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); Map readTestClusterListOctetStringCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterListOctetStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readListOctetStringAttribute( @@ -12438,12 +12604,12 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedListOctetStringAttributeCallback(), readTestClusterListOctetStringCommandParams); - readTestClusterCommandInfo.put( - "readListOctetStringAttribute", readTestClusterListOctetStringAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); Map readTestClusterListStructOctetStringCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterListStructOctetStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readListStructOctetStringAttribute( @@ -12452,13 +12618,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedListStructOctetStringAttributeCallback(), readTestClusterListStructOctetStringCommandParams); - readTestClusterCommandInfo.put( + readTestClusterInteractionInfo.put( "readListStructOctetStringAttribute", - readTestClusterListStructOctetStringAttributeCommandInfo); + readTestClusterListStructOctetStringAttributeInteractionInfo); Map readTestClusterLongOctetStringCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterLongOctetStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readLongOctetStringAttribute( @@ -12466,72 +12632,72 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedOctetStringAttributeCallback(), readTestClusterLongOctetStringCommandParams); - readTestClusterCommandInfo.put( - "readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); Map readTestClusterCharStringCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterCharStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterCharStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readTestClusterCharStringCommandParams); - readTestClusterCommandInfo.put( - "readCharStringAttribute", readTestClusterCharStringAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); Map readTestClusterLongCharStringCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterLongCharStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readLongCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); }, () -> new DelegatedCharStringAttributeCallback(), readTestClusterLongCharStringCommandParams); - readTestClusterCommandInfo.put( - "readLongCharStringAttribute", readTestClusterLongCharStringAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); Map readTestClusterEpochUsCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterEpochUsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readEpochUsAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterEpochUsCommandParams); - readTestClusterCommandInfo.put( - "readEpochUsAttribute", readTestClusterEpochUsAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); Map readTestClusterEpochSCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterEpochSAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterEpochSAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readEpochSAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterEpochSCommandParams); - readTestClusterCommandInfo.put( - "readEpochSAttribute", readTestClusterEpochSAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); Map readTestClusterVendorIdCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterVendorIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterVendorIdCommandParams); - readTestClusterCommandInfo.put( - "readVendorIdAttribute", readTestClusterVendorIdAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); Map readTestClusterListNullablesAndOptionalsStructCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterListNullablesAndOptionalsStructAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readListNullablesAndOptionalsStructAttribute( @@ -12541,205 +12707,205 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedListNullablesAndOptionalsStructAttributeCallback(), readTestClusterListNullablesAndOptionalsStructCommandParams); - readTestClusterCommandInfo.put( + readTestClusterInteractionInfo.put( "readListNullablesAndOptionalsStructAttribute", - readTestClusterListNullablesAndOptionalsStructAttributeCommandInfo); + readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); Map readTestClusterUnsupportedCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterUnsupportedAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readUnsupportedAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readTestClusterUnsupportedCommandParams); - readTestClusterCommandInfo.put( - "readUnsupportedAttribute", readTestClusterUnsupportedAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); Map readTestClusterNullableBooleanCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableBooleanAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); }, () -> new DelegatedBooleanAttributeCallback(), readTestClusterNullableBooleanCommandParams); - readTestClusterCommandInfo.put( - "readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); Map readTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableBitmap8AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableBitmap8Attribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterNullableBitmap8CommandParams); - readTestClusterCommandInfo.put( - "readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); Map readTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableBitmap16AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableBitmap16Attribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterNullableBitmap16CommandParams); - readTestClusterCommandInfo.put( - "readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); Map readTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableBitmap32AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableBitmap32Attribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterNullableBitmap32CommandParams); - readTestClusterCommandInfo.put( - "readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); Map readTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableBitmap64AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableBitmap64Attribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterNullableBitmap64CommandParams); - readTestClusterCommandInfo.put( - "readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); Map readTestClusterNullableInt8uCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableInt8uAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterNullableInt8uCommandParams); - readTestClusterCommandInfo.put( - "readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); Map readTestClusterNullableInt16uCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableInt16uAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableInt16uAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterNullableInt16uCommandParams); - readTestClusterCommandInfo.put( - "readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); Map readTestClusterNullableInt32uCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableInt32uAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableInt32uAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterNullableInt32uCommandParams); - readTestClusterCommandInfo.put( - "readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); Map readTestClusterNullableInt64uCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableInt64uAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableInt64uAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterNullableInt64uCommandParams); - readTestClusterCommandInfo.put( - "readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); Map readTestClusterNullableInt8sCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableInt8sAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableInt8sAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterNullableInt8sCommandParams); - readTestClusterCommandInfo.put( - "readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); Map readTestClusterNullableInt16sCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableInt16sAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableInt16sAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterNullableInt16sCommandParams); - readTestClusterCommandInfo.put( - "readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); Map readTestClusterNullableInt32sCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableInt32sAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableInt32sAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterNullableInt32sCommandParams); - readTestClusterCommandInfo.put( - "readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); Map readTestClusterNullableInt64sCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableInt64sAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableInt64sAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readTestClusterNullableInt64sCommandParams); - readTestClusterCommandInfo.put( - "readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); Map readTestClusterNullableEnum8CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableEnum8AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableEnum8Attribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterNullableEnum8CommandParams); - readTestClusterCommandInfo.put( - "readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); Map readTestClusterNullableEnum16CommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableEnum16AttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableEnum16Attribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterNullableEnum16CommandParams); - readTestClusterCommandInfo.put( - "readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); Map readTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableOctetStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableOctetStringAttribute( @@ -12747,12 +12913,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedOctetStringAttributeCallback(), readTestClusterNullableOctetStringCommandParams); - readTestClusterCommandInfo.put( - "readNullableOctetStringAttribute", readTestClusterNullableOctetStringAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableOctetStringAttribute", + readTestClusterNullableOctetStringAttributeInteractionInfo); Map readTestClusterNullableCharStringCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterNullableCharStringAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readNullableCharStringAttribute( @@ -12760,40 +12927,40 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readTestClusterNullableCharStringCommandParams); - readTestClusterCommandInfo.put( - "readNullableCharStringAttribute", readTestClusterNullableCharStringAttributeCommandInfo); + readTestClusterInteractionInfo.put( + "readNullableCharStringAttribute", + readTestClusterNullableCharStringAttributeInteractionInfo); Map readTestClusterClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readTestClusterClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readTestClusterClusterRevisionCommandParams); - readTestClusterCommandInfo.put( - "readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("testCluster").combineCommands(readTestClusterCommandInfo); - Map readThermostatCommandInfo = new LinkedHashMap<>(); + readTestClusterInteractionInfo.put( + "readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("testCluster", readTestClusterInteractionInfo); + Map readThermostatInteractionInfo = new LinkedHashMap<>(); // read attribute Map readThermostatLocalTemperatureCommandParams = new LinkedHashMap(); - CommandInfo readThermostatLocalTemperatureAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readLocalTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThermostatLocalTemperatureCommandParams); - readThermostatCommandInfo.put( - "readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeCommandInfo); + readThermostatInteractionInfo.put( + "readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); Map readThermostatAbsMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - CommandInfo readThermostatAbsMinHeatSetpointLimitAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readAbsMinHeatSetpointLimitAttribute( @@ -12801,13 +12968,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatAbsMinHeatSetpointLimitCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readAbsMinHeatSetpointLimitAttribute", - readThermostatAbsMinHeatSetpointLimitAttributeCommandInfo); + readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo); Map readThermostatAbsMaxHeatSetpointLimitCommandParams = new LinkedHashMap(); - CommandInfo readThermostatAbsMaxHeatSetpointLimitAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readAbsMaxHeatSetpointLimitAttribute( @@ -12815,13 +12982,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatAbsMaxHeatSetpointLimitCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readAbsMaxHeatSetpointLimitAttribute", - readThermostatAbsMaxHeatSetpointLimitAttributeCommandInfo); + readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo); Map readThermostatAbsMinCoolSetpointLimitCommandParams = new LinkedHashMap(); - CommandInfo readThermostatAbsMinCoolSetpointLimitAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readAbsMinCoolSetpointLimitAttribute( @@ -12829,13 +12996,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatAbsMinCoolSetpointLimitCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readAbsMinCoolSetpointLimitAttribute", - readThermostatAbsMinCoolSetpointLimitAttributeCommandInfo); + readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo); Map readThermostatAbsMaxCoolSetpointLimitCommandParams = new LinkedHashMap(); - CommandInfo readThermostatAbsMaxCoolSetpointLimitAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readAbsMaxCoolSetpointLimitAttribute( @@ -12843,13 +13010,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatAbsMaxCoolSetpointLimitCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readAbsMaxCoolSetpointLimitAttribute", - readThermostatAbsMaxCoolSetpointLimitAttributeCommandInfo); + readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); Map readThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); - CommandInfo readThermostatOccupiedCoolingSetpointAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readOccupiedCoolingSetpointAttribute( @@ -12857,13 +13024,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatOccupiedCoolingSetpointCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readOccupiedCoolingSetpointAttribute", - readThermostatOccupiedCoolingSetpointAttributeCommandInfo); + readThermostatOccupiedCoolingSetpointAttributeInteractionInfo); Map readThermostatOccupiedHeatingSetpointCommandParams = new LinkedHashMap(); - CommandInfo readThermostatOccupiedHeatingSetpointAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatOccupiedHeatingSetpointAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readOccupiedHeatingSetpointAttribute( @@ -12871,13 +13038,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatOccupiedHeatingSetpointCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readOccupiedHeatingSetpointAttribute", - readThermostatOccupiedHeatingSetpointAttributeCommandInfo); + readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); Map readThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - CommandInfo readThermostatMinHeatSetpointLimitAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readMinHeatSetpointLimitAttribute( @@ -12885,13 +13052,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatMinHeatSetpointLimitCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readMinHeatSetpointLimitAttribute", - readThermostatMinHeatSetpointLimitAttributeCommandInfo); + readThermostatMinHeatSetpointLimitAttributeInteractionInfo); Map readThermostatMaxHeatSetpointLimitCommandParams = new LinkedHashMap(); - CommandInfo readThermostatMaxHeatSetpointLimitAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatMaxHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readMaxHeatSetpointLimitAttribute( @@ -12899,13 +13066,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatMaxHeatSetpointLimitCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readMaxHeatSetpointLimitAttribute", - readThermostatMaxHeatSetpointLimitAttributeCommandInfo); + readThermostatMaxHeatSetpointLimitAttributeInteractionInfo); Map readThermostatMinCoolSetpointLimitCommandParams = new LinkedHashMap(); - CommandInfo readThermostatMinCoolSetpointLimitAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatMinCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readMinCoolSetpointLimitAttribute( @@ -12913,13 +13080,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatMinCoolSetpointLimitCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readMinCoolSetpointLimitAttribute", - readThermostatMinCoolSetpointLimitAttributeCommandInfo); + readThermostatMinCoolSetpointLimitAttributeInteractionInfo); Map readThermostatMaxCoolSetpointLimitCommandParams = new LinkedHashMap(); - CommandInfo readThermostatMaxCoolSetpointLimitAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatMaxCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readMaxCoolSetpointLimitAttribute( @@ -12927,13 +13094,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatMaxCoolSetpointLimitCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readMaxCoolSetpointLimitAttribute", - readThermostatMaxCoolSetpointLimitAttributeCommandInfo); + readThermostatMaxCoolSetpointLimitAttributeInteractionInfo); Map readThermostatMinSetpointDeadBandCommandParams = new LinkedHashMap(); - CommandInfo readThermostatMinSetpointDeadBandAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatMinSetpointDeadBandAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readMinSetpointDeadBandAttribute( @@ -12941,12 +13108,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatMinSetpointDeadBandCommandParams); - readThermostatCommandInfo.put( - "readMinSetpointDeadBandAttribute", readThermostatMinSetpointDeadBandAttributeCommandInfo); + readThermostatInteractionInfo.put( + "readMinSetpointDeadBandAttribute", + readThermostatMinSetpointDeadBandAttributeInteractionInfo); Map readThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); - CommandInfo readThermostatControlSequenceOfOperationAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readControlSequenceOfOperationAttribute( @@ -12954,37 +13122,37 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatControlSequenceOfOperationCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readControlSequenceOfOperationAttribute", - readThermostatControlSequenceOfOperationAttributeCommandInfo); + readThermostatControlSequenceOfOperationAttributeInteractionInfo); Map readThermostatSystemModeCommandParams = new LinkedHashMap(); - CommandInfo readThermostatSystemModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatSystemModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readSystemModeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThermostatSystemModeCommandParams); - readThermostatCommandInfo.put( - "readSystemModeAttribute", readThermostatSystemModeAttributeCommandInfo); + readThermostatInteractionInfo.put( + "readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); Map readThermostatStartOfWeekCommandParams = new LinkedHashMap(); - CommandInfo readThermostatStartOfWeekAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readStartOfWeekAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThermostatStartOfWeekCommandParams); - readThermostatCommandInfo.put( - "readStartOfWeekAttribute", readThermostatStartOfWeekAttributeCommandInfo); + readThermostatInteractionInfo.put( + "readStartOfWeekAttribute", readThermostatStartOfWeekAttributeInteractionInfo); Map readThermostatNumberOfWeeklyTransitionsCommandParams = new LinkedHashMap(); - CommandInfo readThermostatNumberOfWeeklyTransitionsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readNumberOfWeeklyTransitionsAttribute( @@ -12992,13 +13160,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatNumberOfWeeklyTransitionsCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readNumberOfWeeklyTransitionsAttribute", - readThermostatNumberOfWeeklyTransitionsAttributeCommandInfo); + readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo); Map readThermostatNumberOfDailyTransitionsCommandParams = new LinkedHashMap(); - CommandInfo readThermostatNumberOfDailyTransitionsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatNumberOfDailyTransitionsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readNumberOfDailyTransitionsAttribute( @@ -13006,73 +13174,73 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatNumberOfDailyTransitionsCommandParams); - readThermostatCommandInfo.put( + readThermostatInteractionInfo.put( "readNumberOfDailyTransitionsAttribute", - readThermostatNumberOfDailyTransitionsAttributeCommandInfo); + readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); Map readThermostatFeatureMapCommandParams = new LinkedHashMap(); - CommandInfo readThermostatFeatureMapAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThermostatFeatureMapCommandParams); - readThermostatCommandInfo.put( - "readFeatureMapAttribute", readThermostatFeatureMapAttributeCommandInfo); + readThermostatInteractionInfo.put( + "readFeatureMapAttribute", readThermostatFeatureMapAttributeInteractionInfo); Map readThermostatClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readThermostatClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThermostatClusterRevisionCommandParams); - readThermostatCommandInfo.put( - "readClusterRevisionAttribute", readThermostatClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("thermostat").combineCommands(readThermostatCommandInfo); - Map readThermostatUserInterfaceConfigurationCommandInfo = + readThermostatInteractionInfo.put( + "readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("thermostat", readThermostatInteractionInfo); + Map readThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); // read attribute Map readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); - CommandInfo readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeCommandInfo = - new CommandInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readTemperatureDisplayModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); - readThermostatUserInterfaceConfigurationCommandInfo.put( + InteractionInfo + readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readTemperatureDisplayModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.put( "readTemperatureDisplayModeAttribute", - readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeCommandInfo); + readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo); Map readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams = new LinkedHashMap(); - CommandInfo readThermostatUserInterfaceConfigurationKeypadLockoutAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) .readKeypadLockoutAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams); - readThermostatUserInterfaceConfigurationCommandInfo.put( + readThermostatUserInterfaceConfigurationInteractionInfo.put( "readKeypadLockoutAttribute", - readThermostatUserInterfaceConfigurationKeypadLockoutAttributeCommandInfo); + readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo); Map readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams = new LinkedHashMap(); - CommandInfo - readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeCommandInfo = - new CommandInfo( + InteractionInfo + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) .readScheduleProgrammingVisibilityAttribute( @@ -13080,94 +13248,98 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams); - readThermostatUserInterfaceConfigurationCommandInfo.put( + readThermostatUserInterfaceConfigurationInteractionInfo.put( "readScheduleProgrammingVisibilityAttribute", - readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeCommandInfo); + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); Map readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readThermostatUserInterfaceConfigurationClusterRevisionAttributeCommandInfo = - new CommandInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams); - readThermostatUserInterfaceConfigurationCommandInfo.put( + InteractionInfo + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.put( "readClusterRevisionAttribute", - readThermostatUserInterfaceConfigurationClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap - .get("thermostatUserInterfaceConfiguration") - .combineCommands(readThermostatUserInterfaceConfigurationCommandInfo); - Map readThreadNetworkDiagnosticsCommandInfo = new LinkedHashMap<>(); + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "thermostatUserInterfaceConfiguration", + readThermostatUserInterfaceConfigurationInteractionInfo); + Map readThreadNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); // read attribute Map readThreadNetworkDiagnosticsChannelCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsChannelAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readChannelAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsChannelCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRoutingRoleAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRoutingRoleAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsRoutingRoleCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readRoutingRoleAttribute", readThreadNetworkDiagnosticsRoutingRoleAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRoutingRoleAttribute", + readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); Map readThreadNetworkDiagnosticsNetworkNameCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsNetworkNameAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readNetworkNameAttribute((ChipClusters.OctetStringAttributeCallback) callback); }, () -> new DelegatedOctetStringAttributeCallback(), readThreadNetworkDiagnosticsNetworkNameCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readNetworkNameAttribute", readThreadNetworkDiagnosticsNetworkNameAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readNetworkNameAttribute", + readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); Map readThreadNetworkDiagnosticsPanIdCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsPanIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readPanIdAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsPanIdCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readExtendedPanIdAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsExtendedPanIdCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readExtendedPanIdAttribute", - readThreadNetworkDiagnosticsExtendedPanIdAttributeCommandInfo); + readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readMeshLocalPrefixAttribute( @@ -13175,25 +13347,26 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedOctetStringAttributeCallback(), readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readMeshLocalPrefixAttribute", - readThreadNetworkDiagnosticsMeshLocalPrefixAttributeCommandInfo); + readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); Map readThreadNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsOverrunCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsOverrunCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readOverrunCountAttribute", readThreadNetworkDiagnosticsOverrunCountAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsNeighborTableListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readNeighborTableListAttribute( @@ -13203,13 +13376,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedNeighborTableListAttributeCallback(), readThreadNetworkDiagnosticsNeighborTableListCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readNeighborTableListAttribute", - readThreadNetworkDiagnosticsNeighborTableListAttributeCommandInfo); + readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRouteTableListCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRouteTableListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRouteTableListAttribute( @@ -13218,127 +13391,129 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedRouteTableListAttributeCallback(), readThreadNetworkDiagnosticsRouteTableListCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRouteTableListAttribute", - readThreadNetworkDiagnosticsRouteTableListAttributeCommandInfo); + readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); Map readThreadNetworkDiagnosticsPartitionIdCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsPartitionIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readPartitionIdAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsPartitionIdCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readPartitionIdAttribute", readThreadNetworkDiagnosticsPartitionIdAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPartitionIdAttribute", + readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); Map readThreadNetworkDiagnosticsWeightingCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsWeightingAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readWeightingAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsWeightingCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); Map readThreadNetworkDiagnosticsDataVersionCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsDataVersionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsDataVersionCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readDataVersionAttribute", readThreadNetworkDiagnosticsDataVersionAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readDataVersionAttribute", + readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsStableDataVersionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readStableDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsStableDataVersionCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readStableDataVersionAttribute", - readThreadNetworkDiagnosticsStableDataVersionAttributeCommandInfo); + readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readLeaderRouterIdAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsLeaderRouterIdCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readLeaderRouterIdAttribute", - readThreadNetworkDiagnosticsLeaderRouterIdAttributeCommandInfo); + readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo); Map readThreadNetworkDiagnosticsDetachedRoleCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsDetachedRoleCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readDetachedRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsDetachedRoleCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readDetachedRoleCountAttribute", - readThreadNetworkDiagnosticsDetachedRoleCountAttributeCommandInfo); + readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsChildRoleCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsChildRoleCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readChildRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsChildRoleCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readChildRoleCountAttribute", - readThreadNetworkDiagnosticsChildRoleCountAttributeCommandInfo); + readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRouterRoleCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRouterRoleCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRouterRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsRouterRoleCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRouterRoleCountAttribute", - readThreadNetworkDiagnosticsRouterRoleCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsLeaderRoleCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsLeaderRoleCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readLeaderRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsLeaderRoleCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readLeaderRoleCountAttribute", - readThreadNetworkDiagnosticsLeaderRoleCountAttributeCommandInfo); + readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsAttachAttemptCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsAttachAttemptCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readAttachAttemptCountAttribute( @@ -13346,14 +13521,14 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsAttachAttemptCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readAttachAttemptCountAttribute", - readThreadNetworkDiagnosticsAttachAttemptCountAttributeCommandInfo); + readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readPartitionIdChangeCountAttribute( @@ -13361,105 +13536,108 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readPartitionIdChangeCountAttribute", - readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeCommandInfo); + readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeCommandInfo = - new CommandInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readBetterPartitionAttachAttemptCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + InteractionInfo + readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readBetterPartitionAttachAttemptCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( "readBetterPartitionAttachAttemptCountAttribute", - readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeCommandInfo); + readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsParentChangeCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsParentChangeCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readParentChangeCountAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsParentChangeCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readParentChangeCountAttribute", - readThreadNetworkDiagnosticsParentChangeCountAttributeCommandInfo); + readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxTotalCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxTotalCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readTxTotalCountAttribute", readThreadNetworkDiagnosticsTxTotalCountAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxTotalCountAttribute", + readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxUnicastCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxUnicastCountAttribute", - readThreadNetworkDiagnosticsTxUnicastCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxBroadcastCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxBroadcastCountAttribute", - readThreadNetworkDiagnosticsTxBroadcastCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxAckRequestedCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxAckRequestedCountAttribute", - readThreadNetworkDiagnosticsTxAckRequestedCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxAckedCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxAckedCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxAckedCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readTxAckedCountAttribute", readThreadNetworkDiagnosticsTxAckedCountAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxAckedCountAttribute", + readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxNoAckRequestedCountAttribute( @@ -13467,146 +13645,151 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxNoAckRequestedCountAttribute", - readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxDataCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxDataCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxDataCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readTxDataCountAttribute", readThreadNetworkDiagnosticsTxDataCountAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxDataCountAttribute", + readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxDataPollCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxDataPollCountAttribute", - readThreadNetworkDiagnosticsTxDataPollCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxBeaconCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxBeaconCountAttribute", - readThreadNetworkDiagnosticsTxBeaconCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxBeaconRequestCountAttribute", - readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxOtherCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxOtherCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readTxOtherCountAttribute", readThreadNetworkDiagnosticsTxOtherCountAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxOtherCountAttribute", + readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxRetryCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxRetryCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxRetryCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readTxRetryCountAttribute", readThreadNetworkDiagnosticsTxRetryCountAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxRetryCountAttribute", + readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeCommandInfo = - new CommandInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxDirectMaxRetryExpiryCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + InteractionInfo + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxDirectMaxRetryExpiryCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxDirectMaxRetryExpiryCountAttribute", - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeCommandInfo = - new CommandInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxIndirectMaxRetryExpiryCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + InteractionInfo + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxIndirectMaxRetryExpiryCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxIndirectMaxRetryExpiryCountAttribute", - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxErrCcaCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxErrCcaCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxErrCcaCountAttribute", - readThreadNetworkDiagnosticsTxErrCcaCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxErrAbortCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxErrAbortCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxErrAbortCountAttribute", - readThreadNetworkDiagnosticsTxErrAbortCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readTxErrBusyChannelCountAttribute( @@ -13614,116 +13797,119 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readTxErrBusyChannelCountAttribute", - readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeCommandInfo); + readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxTotalCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxTotalCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readRxTotalCountAttribute", readThreadNetworkDiagnosticsRxTotalCountAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxTotalCountAttribute", + readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxUnicastCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxUnicastCountAttribute", - readThreadNetworkDiagnosticsRxUnicastCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxBroadcastCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxBroadcastCountAttribute", - readThreadNetworkDiagnosticsRxBroadcastCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxDataCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxDataCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxDataCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readRxDataCountAttribute", readThreadNetworkDiagnosticsRxDataCountAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDataCountAttribute", + readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxDataPollCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxDataPollCountAttribute", - readThreadNetworkDiagnosticsRxDataPollCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxBeaconCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxBeaconCountAttribute", - readThreadNetworkDiagnosticsRxBeaconCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxBeaconRequestCountAttribute", - readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxOtherCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxOtherCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readRxOtherCountAttribute", readThreadNetworkDiagnosticsRxOtherCountAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxOtherCountAttribute", + readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxAddressFilteredCountAttribute( @@ -13731,14 +13917,14 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxAddressFilteredCountAttribute", - readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxDestAddrFilteredCountAttribute( @@ -13746,40 +13932,40 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxDestAddrFilteredCountAttribute", - readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxDuplicatedCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxDuplicatedCountAttribute", - readThreadNetworkDiagnosticsRxDuplicatedCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxErrNoFrameCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxErrNoFrameCountAttribute", - readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxErrUnknownNeighborCountAttribute( @@ -13787,14 +13973,14 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxErrUnknownNeighborCountAttribute", - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxErrInvalidSrcAddrCountAttribute( @@ -13802,90 +13988,90 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxErrInvalidSrcAddrCountAttribute", - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxErrSecCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxErrSecCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxErrSecCountAttribute", - readThreadNetworkDiagnosticsRxErrSecCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxErrFcsCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxErrFcsCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxErrFcsCountAttribute", - readThreadNetworkDiagnosticsRxErrFcsCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readRxErrOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsRxErrOtherCountCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readRxErrOtherCountAttribute", - readThreadNetworkDiagnosticsRxErrOtherCountAttributeCommandInfo); + readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsActiveTimestampAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readActiveTimestampAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsActiveTimestampCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readActiveTimestampAttribute", - readThreadNetworkDiagnosticsActiveTimestampAttributeCommandInfo); + readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsPendingTimestampAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readPendingTimestampAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsPendingTimestampCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readPendingTimestampAttribute", - readThreadNetworkDiagnosticsPendingTimestampAttributeCommandInfo); + readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); Map readThreadNetworkDiagnosticsDelayCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsDelayAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readDelayAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readThreadNetworkDiagnosticsDelayCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readSecurityPolicyAttribute( @@ -13894,43 +14080,45 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedSecurityPolicyAttributeCallback(), readThreadNetworkDiagnosticsSecurityPolicyCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readSecurityPolicyAttribute", - readThreadNetworkDiagnosticsSecurityPolicyAttributeCommandInfo); + readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); Map readThreadNetworkDiagnosticsChannelMaskCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsChannelMaskAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readChannelMaskAttribute((ChipClusters.OctetStringAttributeCallback) callback); }, () -> new DelegatedOctetStringAttributeCallback(), readThreadNetworkDiagnosticsChannelMaskCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( - "readChannelMaskAttribute", readThreadNetworkDiagnosticsChannelMaskAttributeCommandInfo); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readChannelMaskAttribute", + readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); Map readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeCommandInfo = - new CommandInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readOperationalDatasetComponentsAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .OperationalDatasetComponentsAttributeCallback) - callback); - }, - () -> new DelegatedOperationalDatasetComponentsAttributeCallback(), - readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + InteractionInfo + readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readOperationalDatasetComponentsAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .OperationalDatasetComponentsAttributeCallback) + callback); + }, + () -> new DelegatedOperationalDatasetComponentsAttributeCallback(), + readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( "readOperationalDatasetComponentsAttribute", - readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeCommandInfo); + readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); Map readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readActiveNetworkFaultsListAttribute( @@ -13940,32 +14128,29 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedActiveNetworkFaultsListAttributeCallback(), readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readActiveNetworkFaultsListAttribute", - readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCommandInfo); + readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); Map readThreadNetworkDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readThreadNetworkDiagnosticsClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readThreadNetworkDiagnosticsClusterRevisionCommandParams); - readThreadNetworkDiagnosticsCommandInfo.put( + readThreadNetworkDiagnosticsInteractionInfo.put( "readClusterRevisionAttribute", - readThreadNetworkDiagnosticsClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap - .get("threadNetworkDiagnostics") - .combineCommands(readThreadNetworkDiagnosticsCommandInfo); - Map readWakeOnLanCommandInfo = new LinkedHashMap<>(); + readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); + Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); // read attribute Map readWakeOnLanWakeOnLanMacAddressCommandParams = new LinkedHashMap(); - CommandInfo readWakeOnLanWakeOnLanMacAddressAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WakeOnLanCluster) cluster) .readWakeOnLanMacAddressAttribute( @@ -13973,114 +14158,117 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedCharStringAttributeCallback(), readWakeOnLanWakeOnLanMacAddressCommandParams); - readWakeOnLanCommandInfo.put( - "readWakeOnLanMacAddressAttribute", readWakeOnLanWakeOnLanMacAddressAttributeCommandInfo); + readWakeOnLanInteractionInfo.put( + "readWakeOnLanMacAddressAttribute", + readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); Map readWakeOnLanClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readWakeOnLanClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WakeOnLanCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWakeOnLanClusterRevisionCommandParams); - readWakeOnLanCommandInfo.put( - "readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("wakeOnLan").combineCommands(readWakeOnLanCommandInfo); - Map readWiFiNetworkDiagnosticsCommandInfo = new LinkedHashMap<>(); + readWakeOnLanInteractionInfo.put( + "readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); + Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); // read attribute Map readWiFiNetworkDiagnosticsBssidCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsBssidAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readBssidAttribute((ChipClusters.OctetStringAttributeCallback) callback); }, () -> new DelegatedOctetStringAttributeCallback(), readWiFiNetworkDiagnosticsBssidCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( - "readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeCommandInfo); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readSecurityTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWiFiNetworkDiagnosticsSecurityTypeCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( - "readSecurityTypeAttribute", readWiFiNetworkDiagnosticsSecurityTypeAttributeCommandInfo); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readSecurityTypeAttribute", + readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readWiFiVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWiFiNetworkDiagnosticsWiFiVersionCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( - "readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeCommandInfo); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsChannelNumberAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readChannelNumberAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWiFiNetworkDiagnosticsChannelNumberCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( - "readChannelNumberAttribute", readWiFiNetworkDiagnosticsChannelNumberAttributeCommandInfo); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readChannelNumberAttribute", + readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsRssiCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsRssiAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readRssiAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWiFiNetworkDiagnosticsRssiCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( - "readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeCommandInfo); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readBeaconLostCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readWiFiNetworkDiagnosticsBeaconLostCountCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( + readWiFiNetworkDiagnosticsInteractionInfo.put( "readBeaconLostCountAttribute", - readWiFiNetworkDiagnosticsBeaconLostCountAttributeCommandInfo); + readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readBeaconRxCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readWiFiNetworkDiagnosticsBeaconRxCountCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( - "readBeaconRxCountAttribute", readWiFiNetworkDiagnosticsBeaconRxCountAttributeCommandInfo); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBeaconRxCountAttribute", + readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readPacketMulticastRxCountAttribute( @@ -14088,14 +14276,14 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( + readWiFiNetworkDiagnosticsInteractionInfo.put( "readPacketMulticastRxCountAttribute", - readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCommandInfo); + readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readPacketMulticastTxCountAttribute( @@ -14103,93 +14291,93 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedLongAttributeCallback(), readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( + readWiFiNetworkDiagnosticsInteractionInfo.put( "readPacketMulticastTxCountAttribute", - readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCommandInfo); + readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readPacketUnicastRxCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( + readWiFiNetworkDiagnosticsInteractionInfo.put( "readPacketUnicastRxCountAttribute", - readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeCommandInfo); + readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readPacketUnicastTxCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( + readWiFiNetworkDiagnosticsInteractionInfo.put( "readPacketUnicastTxCountAttribute", - readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeCommandInfo); + readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readCurrentMaxRateAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( + readWiFiNetworkDiagnosticsInteractionInfo.put( "readCurrentMaxRateAttribute", - readWiFiNetworkDiagnosticsCurrentMaxRateAttributeCommandInfo); + readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsOverrunCountAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readWiFiNetworkDiagnosticsOverrunCountCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( - "readOverrunCountAttribute", readWiFiNetworkDiagnosticsOverrunCountAttributeCommandInfo); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); Map readWiFiNetworkDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readWiFiNetworkDiagnosticsClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWiFiNetworkDiagnosticsClusterRevisionCommandParams); - readWiFiNetworkDiagnosticsCommandInfo.put( + readWiFiNetworkDiagnosticsInteractionInfo.put( "readClusterRevisionAttribute", - readWiFiNetworkDiagnosticsClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("wiFiNetworkDiagnostics").combineCommands(readWiFiNetworkDiagnosticsCommandInfo); - Map readWindowCoveringCommandInfo = new LinkedHashMap<>(); + readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); + Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); // read attribute Map readWindowCoveringTypeCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringTypeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringTypeCommandParams); - readWindowCoveringCommandInfo.put( - "readTypeAttribute", readWindowCoveringTypeAttributeCommandInfo); + readWindowCoveringInteractionInfo.put( + "readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); Map readWindowCoveringCurrentPositionLiftCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringCurrentPositionLiftAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readCurrentPositionLiftAttribute( @@ -14197,13 +14385,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringCurrentPositionLiftCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readCurrentPositionLiftAttribute", - readWindowCoveringCurrentPositionLiftAttributeCommandInfo); + readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); Map readWindowCoveringCurrentPositionTiltCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringCurrentPositionTiltAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readCurrentPositionTiltAttribute( @@ -14211,25 +14399,25 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringCurrentPositionTiltCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readCurrentPositionTiltAttribute", - readWindowCoveringCurrentPositionTiltAttributeCommandInfo); + readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); Map readWindowCoveringConfigStatusCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringConfigStatusAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readConfigStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringConfigStatusCommandParams); - readWindowCoveringCommandInfo.put( - "readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeCommandInfo); + readWindowCoveringInteractionInfo.put( + "readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringCurrentPositionLiftPercentageAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readCurrentPositionLiftPercentageAttribute( @@ -14237,13 +14425,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringCurrentPositionLiftPercentageCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readCurrentPositionLiftPercentageAttribute", - readWindowCoveringCurrentPositionLiftPercentageAttributeCommandInfo); + readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringCurrentPositionTiltPercentageAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readCurrentPositionTiltPercentageAttribute( @@ -14251,26 +14439,27 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringCurrentPositionTiltPercentageCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readCurrentPositionTiltPercentageAttribute", - readWindowCoveringCurrentPositionTiltPercentageAttributeCommandInfo); + readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo); Map readWindowCoveringOperationalStatusCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringOperationalStatusAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringOperationalStatusAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readOperationalStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringOperationalStatusCommandParams); - readWindowCoveringCommandInfo.put( - "readOperationalStatusAttribute", readWindowCoveringOperationalStatusAttributeCommandInfo); + readWindowCoveringInteractionInfo.put( + "readOperationalStatusAttribute", + readWindowCoveringOperationalStatusAttributeInteractionInfo); Map readWindowCoveringTargetPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readTargetPositionLiftPercent100thsAttribute( @@ -14278,14 +14467,14 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringTargetPositionLiftPercent100thsCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readTargetPositionLiftPercent100thsAttribute", - readWindowCoveringTargetPositionLiftPercent100thsAttributeCommandInfo); + readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); Map readWindowCoveringTargetPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readTargetPositionTiltPercent100thsAttribute( @@ -14293,26 +14482,26 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringTargetPositionTiltPercent100thsCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readTargetPositionTiltPercent100thsAttribute", - readWindowCoveringTargetPositionTiltPercent100thsAttributeCommandInfo); + readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo); Map readWindowCoveringEndProductTypeCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringEndProductTypeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringEndProductTypeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readEndProductTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringEndProductTypeCommandParams); - readWindowCoveringCommandInfo.put( - "readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeCommandInfo); + readWindowCoveringInteractionInfo.put( + "readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); Map readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readCurrentPositionLiftPercent100thsAttribute( @@ -14320,14 +14509,14 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringCurrentPositionLiftPercent100thsCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readCurrentPositionLiftPercent100thsAttribute", - readWindowCoveringCurrentPositionLiftPercent100thsAttributeCommandInfo); + readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); Map readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readCurrentPositionTiltPercent100thsAttribute( @@ -14335,13 +14524,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringCurrentPositionTiltPercent100thsCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readCurrentPositionTiltPercent100thsAttribute", - readWindowCoveringCurrentPositionTiltPercent100thsAttributeCommandInfo); + readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo); Map readWindowCoveringInstalledOpenLimitLiftCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringInstalledOpenLimitLiftAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readInstalledOpenLimitLiftAttribute( @@ -14349,13 +14538,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringInstalledOpenLimitLiftCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readInstalledOpenLimitLiftAttribute", - readWindowCoveringInstalledOpenLimitLiftAttributeCommandInfo); + readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo); Map readWindowCoveringInstalledClosedLimitLiftCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringInstalledClosedLimitLiftAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readInstalledClosedLimitLiftAttribute( @@ -14363,13 +14552,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringInstalledClosedLimitLiftCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readInstalledClosedLimitLiftAttribute", - readWindowCoveringInstalledClosedLimitLiftAttributeCommandInfo); + readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo); Map readWindowCoveringInstalledOpenLimitTiltCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringInstalledOpenLimitTiltAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readInstalledOpenLimitTiltAttribute( @@ -14377,13 +14566,13 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringInstalledOpenLimitTiltCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readInstalledOpenLimitTiltAttribute", - readWindowCoveringInstalledOpenLimitTiltAttributeCommandInfo); + readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo); Map readWindowCoveringInstalledClosedLimitTiltCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringInstalledClosedLimitTiltAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readInstalledClosedLimitTiltAttribute( @@ -14391,59 +14580,58 @@ public Map getReadAttributeMap(Map clu }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringInstalledClosedLimitTiltCommandParams); - readWindowCoveringCommandInfo.put( + readWindowCoveringInteractionInfo.put( "readInstalledClosedLimitTiltAttribute", - readWindowCoveringInstalledClosedLimitTiltAttributeCommandInfo); + readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo); Map readWindowCoveringModeCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringModeAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringModeAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readModeAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringModeCommandParams); - readWindowCoveringCommandInfo.put( - "readModeAttribute", readWindowCoveringModeAttributeCommandInfo); + readWindowCoveringInteractionInfo.put( + "readModeAttribute", readWindowCoveringModeAttributeInteractionInfo); Map readWindowCoveringSafetyStatusCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringSafetyStatusAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringSafetyStatusAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readSafetyStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringSafetyStatusCommandParams); - readWindowCoveringCommandInfo.put( - "readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeCommandInfo); + readWindowCoveringInteractionInfo.put( + "readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); Map readWindowCoveringFeatureMapCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringFeatureMapAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); }, () -> new DelegatedLongAttributeCallback(), readWindowCoveringFeatureMapCommandParams); - readWindowCoveringCommandInfo.put( - "readFeatureMapAttribute", readWindowCoveringFeatureMapAttributeCommandInfo); + readWindowCoveringInteractionInfo.put( + "readFeatureMapAttribute", readWindowCoveringFeatureMapAttributeInteractionInfo); Map readWindowCoveringClusterRevisionCommandParams = new LinkedHashMap(); - CommandInfo readWindowCoveringClusterRevisionAttributeCommandInfo = - new CommandInfo( + InteractionInfo readWindowCoveringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); }, () -> new DelegatedIntegerAttributeCallback(), readWindowCoveringClusterRevisionCommandParams); - readWindowCoveringCommandInfo.put( - "readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeCommandInfo); - // combine the read Attribute into the original commands - clusterMap.get("windowCovering").combineCommands(readWindowCoveringCommandInfo); - return clusterMap; + readWindowCoveringInteractionInfo.put( + "readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); + return readAttributeMap; } }