From 0f165a13cae7ad761d0f09b7441d572b407fe9cb Mon Sep 17 00:00:00 2001 From: Thomas Hartwig Date: Fri, 26 May 2023 10:56:41 +0200 Subject: [PATCH] Update Generated Code --- .../devicecontroller/ClusterIDMapping.java | 4104 ++++++++++ .../devicecontroller/ClusterReadMapping.java | 6912 +++++++++++++++++ .../devicecontroller/ClusterWriteMapping.java | 235 +- .../MTRAttributeSpecifiedCheck.mm | 2268 ++++++ 4 files changed, 13356 insertions(+), 163 deletions(-) diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index 6b1923486f9f85..e8210fe81f5dc4 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -247,6 +247,114 @@ public static BaseCluster getCluster(long clusterId) { if (clusterId == OccupancySensing.ID) { return new OccupancySensing(); } + if (clusterId == CarbonMonoxideConcentrationMeasurement.ID) { + return new CarbonMonoxideConcentrationMeasurement(); + } + if (clusterId == CarbonDioxideConcentrationMeasurement.ID) { + return new CarbonDioxideConcentrationMeasurement(); + } + if (clusterId == EthyleneConcentrationMeasurement.ID) { + return new EthyleneConcentrationMeasurement(); + } + if (clusterId == EthyleneOxideConcentrationMeasurement.ID) { + return new EthyleneOxideConcentrationMeasurement(); + } + if (clusterId == HydrogenConcentrationMeasurement.ID) { + return new HydrogenConcentrationMeasurement(); + } + if (clusterId == HydrogenSulfideConcentrationMeasurement.ID) { + return new HydrogenSulfideConcentrationMeasurement(); + } + if (clusterId == NitricOxideConcentrationMeasurement.ID) { + return new NitricOxideConcentrationMeasurement(); + } + if (clusterId == NitrogenDioxideConcentrationMeasurement.ID) { + return new NitrogenDioxideConcentrationMeasurement(); + } + if (clusterId == OxygenConcentrationMeasurement.ID) { + return new OxygenConcentrationMeasurement(); + } + if (clusterId == OzoneConcentrationMeasurement.ID) { + return new OzoneConcentrationMeasurement(); + } + if (clusterId == SulfurDioxideConcentrationMeasurement.ID) { + return new SulfurDioxideConcentrationMeasurement(); + } + if (clusterId == DissolvedOxygenConcentrationMeasurement.ID) { + return new DissolvedOxygenConcentrationMeasurement(); + } + if (clusterId == BromateConcentrationMeasurement.ID) { + return new BromateConcentrationMeasurement(); + } + if (clusterId == ChloraminesConcentrationMeasurement.ID) { + return new ChloraminesConcentrationMeasurement(); + } + if (clusterId == ChlorineConcentrationMeasurement.ID) { + return new ChlorineConcentrationMeasurement(); + } + if (clusterId == FecalColiformEColiConcentrationMeasurement.ID) { + return new FecalColiformEColiConcentrationMeasurement(); + } + if (clusterId == FluorideConcentrationMeasurement.ID) { + return new FluorideConcentrationMeasurement(); + } + if (clusterId == HaloaceticAcidsConcentrationMeasurement.ID) { + return new HaloaceticAcidsConcentrationMeasurement(); + } + if (clusterId == TotalTrihalomethanesConcentrationMeasurement.ID) { + return new TotalTrihalomethanesConcentrationMeasurement(); + } + if (clusterId == TotalColiformBacteriaConcentrationMeasurement.ID) { + return new TotalColiformBacteriaConcentrationMeasurement(); + } + if (clusterId == TurbidityConcentrationMeasurement.ID) { + return new TurbidityConcentrationMeasurement(); + } + if (clusterId == CopperConcentrationMeasurement.ID) { + return new CopperConcentrationMeasurement(); + } + if (clusterId == LeadConcentrationMeasurement.ID) { + return new LeadConcentrationMeasurement(); + } + if (clusterId == ManganeseConcentrationMeasurement.ID) { + return new ManganeseConcentrationMeasurement(); + } + if (clusterId == SulfateConcentrationMeasurement.ID) { + return new SulfateConcentrationMeasurement(); + } + if (clusterId == BromodichloromethaneConcentrationMeasurement.ID) { + return new BromodichloromethaneConcentrationMeasurement(); + } + if (clusterId == BromoformConcentrationMeasurement.ID) { + return new BromoformConcentrationMeasurement(); + } + if (clusterId == ChlorodibromomethaneConcentrationMeasurement.ID) { + return new ChlorodibromomethaneConcentrationMeasurement(); + } + if (clusterId == ChloroformConcentrationMeasurement.ID) { + return new ChloroformConcentrationMeasurement(); + } + if (clusterId == SodiumConcentrationMeasurement.ID) { + return new SodiumConcentrationMeasurement(); + } + if (clusterId == Pm25ConcentrationMeasurement.ID) { + return new Pm25ConcentrationMeasurement(); + } + if (clusterId == FormaldehydeConcentrationMeasurement.ID) { + return new FormaldehydeConcentrationMeasurement(); + } + if (clusterId == Pm1ConcentrationMeasurement.ID) { + return new Pm1ConcentrationMeasurement(); + } + if (clusterId == Pm10ConcentrationMeasurement.ID) { + return new Pm10ConcentrationMeasurement(); + } + if (clusterId == TotalVolatileOrganicCompoundsConcentrationMeasurement.ID) { + return new TotalVolatileOrganicCompoundsConcentrationMeasurement(); + } + if (clusterId == RadonConcentrationMeasurement.ID) { + return new RadonConcentrationMeasurement(); + } if (clusterId == WakeOnLan.ID) { return new WakeOnLan(); } @@ -10545,6 +10653,4002 @@ public long getCommandID(String name) throws IllegalArgumentException { return Command.valueOf(name).getID(); } } + public static class CarbonMonoxideConcentrationMeasurement implements BaseCluster { + public static final long ID = 1036L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class CarbonDioxideConcentrationMeasurement implements BaseCluster { + public static final long ID = 1037L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class EthyleneConcentrationMeasurement implements BaseCluster { + public static final long ID = 1038L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class EthyleneOxideConcentrationMeasurement implements BaseCluster { + public static final long ID = 1039L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class HydrogenConcentrationMeasurement implements BaseCluster { + public static final long ID = 1040L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class HydrogenSulfideConcentrationMeasurement implements BaseCluster { + public static final long ID = 1041L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class NitricOxideConcentrationMeasurement implements BaseCluster { + public static final long ID = 1042L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class NitrogenDioxideConcentrationMeasurement implements BaseCluster { + public static final long ID = 1043L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class OxygenConcentrationMeasurement implements BaseCluster { + public static final long ID = 1044L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class OzoneConcentrationMeasurement implements BaseCluster { + public static final long ID = 1045L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class SulfurDioxideConcentrationMeasurement implements BaseCluster { + public static final long ID = 1046L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class DissolvedOxygenConcentrationMeasurement implements BaseCluster { + public static final long ID = 1047L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class BromateConcentrationMeasurement implements BaseCluster { + public static final long ID = 1048L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ChloraminesConcentrationMeasurement implements BaseCluster { + public static final long ID = 1049L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ChlorineConcentrationMeasurement implements BaseCluster { + public static final long ID = 1050L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class FecalColiformEColiConcentrationMeasurement implements BaseCluster { + public static final long ID = 1051L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class FluorideConcentrationMeasurement implements BaseCluster { + public static final long ID = 1052L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class HaloaceticAcidsConcentrationMeasurement implements BaseCluster { + public static final long ID = 1053L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TotalTrihalomethanesConcentrationMeasurement implements BaseCluster { + public static final long ID = 1054L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TotalColiformBacteriaConcentrationMeasurement implements BaseCluster { + public static final long ID = 1055L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TurbidityConcentrationMeasurement implements BaseCluster { + public static final long ID = 1056L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class CopperConcentrationMeasurement implements BaseCluster { + public static final long ID = 1057L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class LeadConcentrationMeasurement implements BaseCluster { + public static final long ID = 1058L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ManganeseConcentrationMeasurement implements BaseCluster { + public static final long ID = 1059L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class SulfateConcentrationMeasurement implements BaseCluster { + public static final long ID = 1060L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class BromodichloromethaneConcentrationMeasurement implements BaseCluster { + public static final long ID = 1061L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class BromoformConcentrationMeasurement implements BaseCluster { + public static final long ID = 1062L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ChlorodibromomethaneConcentrationMeasurement implements BaseCluster { + public static final long ID = 1063L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ChloroformConcentrationMeasurement implements BaseCluster { + public static final long ID = 1064L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class SodiumConcentrationMeasurement implements BaseCluster { + public static final long ID = 1065L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Pm25ConcentrationMeasurement implements BaseCluster { + public static final long ID = 1066L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class FormaldehydeConcentrationMeasurement implements BaseCluster { + public static final long ID = 1067L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Pm1ConcentrationMeasurement implements BaseCluster { + public static final long ID = 1068L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Pm10ConcentrationMeasurement implements BaseCluster { + public static final long ID = 1069L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TotalVolatileOrganicCompoundsConcentrationMeasurement implements BaseCluster { + public static final long ID = 1070L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class RadonConcentrationMeasurement implements BaseCluster { + public static final long ID = 1071L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + PeakMeasuredValue(3L), + PeakMeasuredValueWindow(4L), + AverageMeasuredValue(5L), + AverageMeasuredValueWindow(6L), + Uncertainty(7L), + MeasurementUnit(8L), + MeasurementMedium(9L), + LevelValue(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } public static class WakeOnLan implements BaseCluster { public static final long ID = 1283L; public long getID() { diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java index 7269e399a7fada..94b569becfe308 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -11812,6 +11812,6882 @@ private static Map readOccupancySensingInteractionInfo( return result; } + private static Map readCarbonMonoxideConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readCarbonMonoxideConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.CarbonMonoxideConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonMonoxideConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.CarbonMonoxideConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonMonoxideConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.CarbonMonoxideConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonMonoxideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.CarbonMonoxideConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonMonoxideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readCarbonMonoxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.CarbonMonoxideConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonMonoxideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readCarbonMonoxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readCarbonMonoxideConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readCarbonMonoxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readCarbonMonoxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readCarbonMonoxideConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.CarbonMonoxideConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonMonoxideConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.CarbonMonoxideConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonMonoxideConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.CarbonMonoxideConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonMonoxideConcentrationMeasurementClusterEventListAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readCarbonMonoxideConcentrationMeasurementEventListAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.CarbonMonoxideConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonMonoxideConcentrationMeasurementClusterAttributeListAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readCarbonMonoxideConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readCarbonMonoxideConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readCarbonMonoxideConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonMonoxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonMonoxideConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCarbonMonoxideConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readCarbonMonoxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readCarbonDioxideConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readCarbonDioxideConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.CarbonDioxideConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonDioxideConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readCarbonDioxideConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readCarbonDioxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.CarbonDioxideConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonDioxideConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readCarbonDioxideConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.CarbonDioxideConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonDioxideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readCarbonDioxideConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.CarbonDioxideConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonDioxideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readCarbonDioxideConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCarbonDioxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readCarbonDioxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.CarbonDioxideConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonDioxideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readCarbonDioxideConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCarbonDioxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readCarbonDioxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readCarbonDioxideConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readCarbonDioxideConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCarbonDioxideConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readCarbonDioxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCarbonDioxideConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readCarbonDioxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCarbonDioxideConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readCarbonDioxideConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.CarbonDioxideConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonDioxideConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readCarbonDioxideConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.CarbonDioxideConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonDioxideConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readCarbonDioxideConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.CarbonDioxideConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonDioxideConcentrationMeasurementClusterEventListAttributeCallback(), + readCarbonDioxideConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readCarbonDioxideConcentrationMeasurementEventListAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.CarbonDioxideConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCarbonDioxideConcentrationMeasurementClusterAttributeListAttributeCallback(), + readCarbonDioxideConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readCarbonDioxideConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCarbonDioxideConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readCarbonDioxideConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readCarbonDioxideConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readCarbonDioxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CarbonDioxideConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCarbonDioxideConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readCarbonDioxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readEthyleneConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readEthyleneConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.EthyleneConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readEthyleneConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readEthyleneConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.EthyleneConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readEthyleneConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readEthyleneConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.EthyleneConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readEthyleneConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readEthyleneConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.EthyleneConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readEthyleneConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readEthyleneConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthyleneConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readEthyleneConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.EthyleneConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readEthyleneConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readEthyleneConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthyleneConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readEthyleneConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readEthyleneConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readEthyleneConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthyleneConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readEthyleneConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthyleneConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readEthyleneConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthyleneConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readEthyleneConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.EthyleneConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readEthyleneConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readEthyleneConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.EthyleneConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readEthyleneConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readEthyleneConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.EthyleneConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneConcentrationMeasurementClusterEventListAttributeCallback(), + readEthyleneConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readEthyleneConcentrationMeasurementEventListAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.EthyleneConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneConcentrationMeasurementClusterAttributeListAttributeCallback(), + readEthyleneConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readEthyleneConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthyleneConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readEthyleneConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readEthyleneConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthyleneConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readEthyleneConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readEthyleneOxideConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readEthyleneOxideConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.EthyleneOxideConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneOxideConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readEthyleneOxideConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readEthyleneOxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.EthyleneOxideConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneOxideConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readEthyleneOxideConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readEthyleneOxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.EthyleneOxideConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneOxideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readEthyleneOxideConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readEthyleneOxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.EthyleneOxideConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneOxideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readEthyleneOxideConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readEthyleneOxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthyleneOxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readEthyleneOxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.EthyleneOxideConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneOxideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readEthyleneOxideConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readEthyleneOxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthyleneOxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readEthyleneOxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readEthyleneOxideConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readEthyleneOxideConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthyleneOxideConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readEthyleneOxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthyleneOxideConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readEthyleneOxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthyleneOxideConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readEthyleneOxideConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.EthyleneOxideConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneOxideConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readEthyleneOxideConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readEthyleneOxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.EthyleneOxideConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneOxideConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readEthyleneOxideConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readEthyleneOxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.EthyleneOxideConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneOxideConcentrationMeasurementClusterEventListAttributeCallback(), + readEthyleneOxideConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readEthyleneOxideConcentrationMeasurementEventListAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.EthyleneOxideConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthyleneOxideConcentrationMeasurementClusterAttributeListAttributeCallback(), + readEthyleneOxideConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readEthyleneOxideConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthyleneOxideConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readEthyleneOxideConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readEthyleneOxideConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readEthyleneOxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthyleneOxideConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthyleneOxideConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readEthyleneOxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readHydrogenConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readHydrogenConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.HydrogenConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readHydrogenConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readHydrogenConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.HydrogenConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readHydrogenConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readHydrogenConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.HydrogenConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readHydrogenConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readHydrogenConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.HydrogenConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readHydrogenConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readHydrogenConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHydrogenConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readHydrogenConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.HydrogenConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readHydrogenConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readHydrogenConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHydrogenConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readHydrogenConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readHydrogenConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readHydrogenConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHydrogenConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readHydrogenConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHydrogenConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readHydrogenConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHydrogenConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readHydrogenConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.HydrogenConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readHydrogenConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readHydrogenConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.HydrogenConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readHydrogenConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readHydrogenConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.HydrogenConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenConcentrationMeasurementClusterEventListAttributeCallback(), + readHydrogenConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readHydrogenConcentrationMeasurementEventListAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.HydrogenConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenConcentrationMeasurementClusterAttributeListAttributeCallback(), + readHydrogenConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readHydrogenConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHydrogenConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readHydrogenConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readHydrogenConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHydrogenConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readHydrogenConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readHydrogenSulfideConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readHydrogenSulfideConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.HydrogenSulfideConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenSulfideConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readHydrogenSulfideConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.HydrogenSulfideConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenSulfideConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readHydrogenSulfideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.HydrogenSulfideConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenSulfideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readHydrogenSulfideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.HydrogenSulfideConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenSulfideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readHydrogenSulfideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readHydrogenSulfideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.HydrogenSulfideConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenSulfideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readHydrogenSulfideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readHydrogenSulfideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readHydrogenSulfideConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readHydrogenSulfideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readHydrogenSulfideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readHydrogenSulfideConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.HydrogenSulfideConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenSulfideConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readHydrogenSulfideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.HydrogenSulfideConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenSulfideConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readHydrogenSulfideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.HydrogenSulfideConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenSulfideConcentrationMeasurementClusterEventListAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readHydrogenSulfideConcentrationMeasurementEventListAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.HydrogenSulfideConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHydrogenSulfideConcentrationMeasurementClusterAttributeListAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readHydrogenSulfideConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readHydrogenSulfideConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readHydrogenSulfideConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readHydrogenSulfideConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HydrogenSulfideConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHydrogenSulfideConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readHydrogenSulfideConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readNitricOxideConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readNitricOxideConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.NitricOxideConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitricOxideConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readNitricOxideConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readNitricOxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.NitricOxideConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitricOxideConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readNitricOxideConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readNitricOxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.NitricOxideConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitricOxideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readNitricOxideConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readNitricOxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.NitricOxideConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitricOxideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readNitricOxideConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readNitricOxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readNitricOxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readNitricOxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.NitricOxideConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitricOxideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readNitricOxideConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readNitricOxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readNitricOxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readNitricOxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readNitricOxideConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readNitricOxideConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNitricOxideConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readNitricOxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNitricOxideConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readNitricOxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNitricOxideConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readNitricOxideConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.NitricOxideConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitricOxideConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readNitricOxideConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readNitricOxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.NitricOxideConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitricOxideConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readNitricOxideConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readNitricOxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.NitricOxideConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitricOxideConcentrationMeasurementClusterEventListAttributeCallback(), + readNitricOxideConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readNitricOxideConcentrationMeasurementEventListAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.NitricOxideConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitricOxideConcentrationMeasurementClusterAttributeListAttributeCallback(), + readNitricOxideConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readNitricOxideConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readNitricOxideConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readNitricOxideConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readNitricOxideConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readNitricOxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitricOxideConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNitricOxideConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readNitricOxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readNitrogenDioxideConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readNitrogenDioxideConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.NitrogenDioxideConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitrogenDioxideConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.NitrogenDioxideConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitrogenDioxideConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.NitrogenDioxideConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitrogenDioxideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.NitrogenDioxideConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitrogenDioxideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readNitrogenDioxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.NitrogenDioxideConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitrogenDioxideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readNitrogenDioxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readNitrogenDioxideConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readNitrogenDioxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readNitrogenDioxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readNitrogenDioxideConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.NitrogenDioxideConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitrogenDioxideConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.NitrogenDioxideConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitrogenDioxideConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.NitrogenDioxideConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitrogenDioxideConcentrationMeasurementClusterEventListAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readNitrogenDioxideConcentrationMeasurementEventListAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.NitrogenDioxideConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNitrogenDioxideConcentrationMeasurementClusterAttributeListAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readNitrogenDioxideConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readNitrogenDioxideConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readNitrogenDioxideConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readNitrogenDioxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NitrogenDioxideConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNitrogenDioxideConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readNitrogenDioxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readOxygenConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readOxygenConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.OxygenConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOxygenConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readOxygenConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readOxygenConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.OxygenConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOxygenConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readOxygenConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readOxygenConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.OxygenConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOxygenConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readOxygenConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readOxygenConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.OxygenConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOxygenConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readOxygenConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readOxygenConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOxygenConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readOxygenConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.OxygenConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOxygenConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readOxygenConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readOxygenConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOxygenConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readOxygenConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readOxygenConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readOxygenConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOxygenConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readOxygenConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOxygenConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readOxygenConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOxygenConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readOxygenConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.OxygenConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOxygenConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readOxygenConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readOxygenConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.OxygenConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOxygenConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readOxygenConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readOxygenConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.OxygenConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOxygenConcentrationMeasurementClusterEventListAttributeCallback(), + readOxygenConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readOxygenConcentrationMeasurementEventListAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.OxygenConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOxygenConcentrationMeasurementClusterAttributeListAttributeCallback(), + readOxygenConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readOxygenConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOxygenConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readOxygenConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readOxygenConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOxygenConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OxygenConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOxygenConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readOxygenConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readOzoneConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readOzoneConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.OzoneConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readOzoneConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readOzoneConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.OzoneConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readOzoneConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readOzoneConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.OzoneConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readOzoneConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readOzoneConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.OzoneConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readOzoneConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readOzoneConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOzoneConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readOzoneConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.OzoneConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readOzoneConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readOzoneConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOzoneConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readOzoneConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readOzoneConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readOzoneConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readOzoneConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readOzoneConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readOzoneConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.OzoneConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readOzoneConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readOzoneConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.OzoneConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readOzoneConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readOzoneConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.OzoneConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneConcentrationMeasurementClusterEventListAttributeCallback(), + readOzoneConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readOzoneConcentrationMeasurementEventListAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.OzoneConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneConcentrationMeasurementClusterAttributeListAttributeCallback(), + readOzoneConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readOzoneConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOzoneConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readOzoneConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readOzoneConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readOzoneConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readSulfurDioxideConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readSulfurDioxideConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.SulfurDioxideConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfurDioxideConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readSulfurDioxideConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readSulfurDioxideConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.SulfurDioxideConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfurDioxideConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readSulfurDioxideConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readSulfurDioxideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.SulfurDioxideConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfurDioxideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readSulfurDioxideConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readSulfurDioxideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.SulfurDioxideConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfurDioxideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readSulfurDioxideConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readSulfurDioxideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSulfurDioxideConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readSulfurDioxideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.SulfurDioxideConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfurDioxideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readSulfurDioxideConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readSulfurDioxideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSulfurDioxideConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readSulfurDioxideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readSulfurDioxideConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readSulfurDioxideConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSulfurDioxideConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readSulfurDioxideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSulfurDioxideConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readSulfurDioxideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSulfurDioxideConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readSulfurDioxideConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.SulfurDioxideConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfurDioxideConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readSulfurDioxideConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readSulfurDioxideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.SulfurDioxideConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfurDioxideConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readSulfurDioxideConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readSulfurDioxideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.SulfurDioxideConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfurDioxideConcentrationMeasurementClusterEventListAttributeCallback(), + readSulfurDioxideConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readSulfurDioxideConcentrationMeasurementEventListAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.SulfurDioxideConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfurDioxideConcentrationMeasurementClusterAttributeListAttributeCallback(), + readSulfurDioxideConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readSulfurDioxideConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSulfurDioxideConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readSulfurDioxideConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readSulfurDioxideConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readSulfurDioxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfurDioxideConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSulfurDioxideConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readSulfurDioxideConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readDissolvedOxygenConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readDissolvedOxygenConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.DissolvedOxygenConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDissolvedOxygenConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readDissolvedOxygenConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.DissolvedOxygenConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDissolvedOxygenConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readDissolvedOxygenConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.DissolvedOxygenConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDissolvedOxygenConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readDissolvedOxygenConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.DissolvedOxygenConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDissolvedOxygenConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readDissolvedOxygenConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readDissolvedOxygenConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.DissolvedOxygenConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDissolvedOxygenConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readDissolvedOxygenConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readDissolvedOxygenConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readDissolvedOxygenConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readDissolvedOxygenConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readDissolvedOxygenConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readDissolvedOxygenConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.DissolvedOxygenConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDissolvedOxygenConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readDissolvedOxygenConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.DissolvedOxygenConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDissolvedOxygenConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readDissolvedOxygenConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.DissolvedOxygenConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDissolvedOxygenConcentrationMeasurementClusterEventListAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readDissolvedOxygenConcentrationMeasurementEventListAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.DissolvedOxygenConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDissolvedOxygenConcentrationMeasurementClusterAttributeListAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readDissolvedOxygenConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readDissolvedOxygenConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readDissolvedOxygenConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readDissolvedOxygenConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DissolvedOxygenConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDissolvedOxygenConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readDissolvedOxygenConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBromateConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBromateConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.BromateConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromateConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readBromateConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readBromateConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readBromateConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.BromateConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromateConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readBromateConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readBromateConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readBromateConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.BromateConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromateConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readBromateConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readBromateConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readBromateConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.BromateConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromateConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readBromateConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readBromateConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readBromateConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBromateConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readBromateConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readBromateConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.BromateConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromateConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readBromateConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readBromateConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readBromateConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBromateConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readBromateConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readBromateConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readBromateConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readBromateConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readBromateConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromateConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readBromateConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readBromateConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromateConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readBromateConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readBromateConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromateConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readBromateConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readBromateConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BromateConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromateConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readBromateConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBromateConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readBromateConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BromateConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromateConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readBromateConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBromateConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readBromateConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.BromateConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromateConcentrationMeasurementClusterEventListAttributeCallback(), + readBromateConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readBromateConcentrationMeasurementEventListAttributeInteractionInfo); + Map readBromateConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.BromateConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromateConcentrationMeasurementClusterAttributeListAttributeCallback(), + readBromateConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBromateConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readBromateConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBromateConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBromateConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readBromateConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBromateConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromateConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromateConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBromateConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readChloraminesConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readChloraminesConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.ChloraminesConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloraminesConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readChloraminesConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readChloraminesConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.ChloraminesConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloraminesConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readChloraminesConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readChloraminesConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.ChloraminesConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloraminesConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readChloraminesConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readChloraminesConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.ChloraminesConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloraminesConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readChloraminesConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readChloraminesConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChloraminesConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readChloraminesConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.ChloraminesConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloraminesConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readChloraminesConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readChloraminesConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChloraminesConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readChloraminesConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readChloraminesConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readChloraminesConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChloraminesConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readChloraminesConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChloraminesConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readChloraminesConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChloraminesConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readChloraminesConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ChloraminesConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloraminesConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readChloraminesConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readChloraminesConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ChloraminesConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloraminesConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readChloraminesConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readChloraminesConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.ChloraminesConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloraminesConcentrationMeasurementClusterEventListAttributeCallback(), + readChloraminesConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readChloraminesConcentrationMeasurementEventListAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.ChloraminesConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloraminesConcentrationMeasurementClusterAttributeListAttributeCallback(), + readChloraminesConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readChloraminesConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChloraminesConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readChloraminesConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readChloraminesConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readChloraminesConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloraminesConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChloraminesConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readChloraminesConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readChlorineConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readChlorineConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.ChlorineConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorineConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readChlorineConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readChlorineConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.ChlorineConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorineConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readChlorineConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readChlorineConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.ChlorineConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorineConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readChlorineConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readChlorineConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.ChlorineConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorineConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readChlorineConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readChlorineConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChlorineConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readChlorineConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.ChlorineConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorineConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readChlorineConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readChlorineConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChlorineConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readChlorineConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readChlorineConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readChlorineConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChlorineConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readChlorineConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChlorineConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readChlorineConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChlorineConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readChlorineConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ChlorineConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorineConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readChlorineConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readChlorineConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ChlorineConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorineConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readChlorineConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readChlorineConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.ChlorineConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorineConcentrationMeasurementClusterEventListAttributeCallback(), + readChlorineConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readChlorineConcentrationMeasurementEventListAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.ChlorineConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorineConcentrationMeasurementClusterAttributeListAttributeCallback(), + readChlorineConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readChlorineConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChlorineConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readChlorineConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readChlorineConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readChlorineConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorineConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChlorineConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readChlorineConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readFecalColiformEColiConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readFecalColiformEColiConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.FecalColiformEColiConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFecalColiformEColiConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readFecalColiformEColiConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.FecalColiformEColiConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFecalColiformEColiConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readFecalColiformEColiConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.FecalColiformEColiConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFecalColiformEColiConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readFecalColiformEColiConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.FecalColiformEColiConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFecalColiformEColiConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readFecalColiformEColiConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readFecalColiformEColiConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.FecalColiformEColiConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFecalColiformEColiConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readFecalColiformEColiConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readFecalColiformEColiConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readFecalColiformEColiConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readFecalColiformEColiConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readFecalColiformEColiConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readFecalColiformEColiConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.FecalColiformEColiConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFecalColiformEColiConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readFecalColiformEColiConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.FecalColiformEColiConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFecalColiformEColiConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readFecalColiformEColiConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.FecalColiformEColiConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFecalColiformEColiConcentrationMeasurementClusterEventListAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readFecalColiformEColiConcentrationMeasurementEventListAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.FecalColiformEColiConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFecalColiformEColiConcentrationMeasurementClusterAttributeListAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readFecalColiformEColiConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readFecalColiformEColiConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readFecalColiformEColiConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFecalColiformEColiConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FecalColiformEColiConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFecalColiformEColiConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readFecalColiformEColiConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readFluorideConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readFluorideConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.FluorideConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFluorideConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readFluorideConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readFluorideConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.FluorideConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFluorideConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readFluorideConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readFluorideConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.FluorideConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFluorideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readFluorideConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readFluorideConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.FluorideConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFluorideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readFluorideConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readFluorideConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFluorideConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readFluorideConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.FluorideConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFluorideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readFluorideConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readFluorideConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFluorideConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readFluorideConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readFluorideConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readFluorideConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFluorideConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readFluorideConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFluorideConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readFluorideConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFluorideConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readFluorideConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.FluorideConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFluorideConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readFluorideConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readFluorideConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.FluorideConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFluorideConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readFluorideConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readFluorideConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.FluorideConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFluorideConcentrationMeasurementClusterEventListAttributeCallback(), + readFluorideConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readFluorideConcentrationMeasurementEventListAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.FluorideConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFluorideConcentrationMeasurementClusterAttributeListAttributeCallback(), + readFluorideConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readFluorideConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFluorideConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readFluorideConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readFluorideConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFluorideConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FluorideConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFluorideConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readFluorideConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readHaloaceticAcidsConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readHaloaceticAcidsConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHaloaceticAcidsConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readHaloaceticAcidsConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHaloaceticAcidsConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readHaloaceticAcidsConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHaloaceticAcidsConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readHaloaceticAcidsConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHaloaceticAcidsConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readHaloaceticAcidsConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readHaloaceticAcidsConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHaloaceticAcidsConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readHaloaceticAcidsConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readHaloaceticAcidsConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readHaloaceticAcidsConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readHaloaceticAcidsConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readHaloaceticAcidsConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readHaloaceticAcidsConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHaloaceticAcidsConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readHaloaceticAcidsConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHaloaceticAcidsConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readHaloaceticAcidsConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHaloaceticAcidsConcentrationMeasurementClusterEventListAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readHaloaceticAcidsConcentrationMeasurementEventListAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHaloaceticAcidsConcentrationMeasurementClusterAttributeListAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readHaloaceticAcidsConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readHaloaceticAcidsConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readHaloaceticAcidsConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readHaloaceticAcidsConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HaloaceticAcidsConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHaloaceticAcidsConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readHaloaceticAcidsConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTotalTrihalomethanesConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTotalTrihalomethanesConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalTrihalomethanesConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readTotalTrihalomethanesConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalTrihalomethanesConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readTotalTrihalomethanesConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalTrihalomethanesConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readTotalTrihalomethanesConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalTrihalomethanesConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readTotalTrihalomethanesConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readTotalTrihalomethanesConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalTrihalomethanesConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readTotalTrihalomethanesConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readTotalTrihalomethanesConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readTotalTrihalomethanesConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readTotalTrihalomethanesConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readTotalTrihalomethanesConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readTotalTrihalomethanesConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalTrihalomethanesConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTotalTrihalomethanesConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalTrihalomethanesConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTotalTrihalomethanesConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalTrihalomethanesConcentrationMeasurementClusterEventListAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readTotalTrihalomethanesConcentrationMeasurementEventListAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalTrihalomethanesConcentrationMeasurementClusterAttributeListAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTotalTrihalomethanesConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTotalTrihalomethanesConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readTotalTrihalomethanesConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTotalTrihalomethanesConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalTrihalomethanesConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalTrihalomethanesConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTotalTrihalomethanesConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTotalColiformBacteriaConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTotalColiformBacteriaConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalColiformBacteriaConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readTotalColiformBacteriaConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalColiformBacteriaConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readTotalColiformBacteriaConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalColiformBacteriaConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readTotalColiformBacteriaConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalColiformBacteriaConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readTotalColiformBacteriaConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readTotalColiformBacteriaConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalColiformBacteriaConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readTotalColiformBacteriaConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readTotalColiformBacteriaConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readTotalColiformBacteriaConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readTotalColiformBacteriaConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readTotalColiformBacteriaConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readTotalColiformBacteriaConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalColiformBacteriaConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTotalColiformBacteriaConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalColiformBacteriaConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTotalColiformBacteriaConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalColiformBacteriaConcentrationMeasurementClusterEventListAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readTotalColiformBacteriaConcentrationMeasurementEventListAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalColiformBacteriaConcentrationMeasurementClusterAttributeListAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTotalColiformBacteriaConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTotalColiformBacteriaConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readTotalColiformBacteriaConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTotalColiformBacteriaConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalColiformBacteriaConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalColiformBacteriaConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTotalColiformBacteriaConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTurbidityConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTurbidityConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.TurbidityConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTurbidityConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readTurbidityConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readTurbidityConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.TurbidityConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTurbidityConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readTurbidityConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readTurbidityConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.TurbidityConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTurbidityConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readTurbidityConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readTurbidityConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.TurbidityConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTurbidityConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readTurbidityConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readTurbidityConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTurbidityConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readTurbidityConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.TurbidityConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTurbidityConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readTurbidityConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readTurbidityConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTurbidityConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readTurbidityConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readTurbidityConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readTurbidityConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTurbidityConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readTurbidityConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTurbidityConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readTurbidityConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTurbidityConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readTurbidityConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TurbidityConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTurbidityConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readTurbidityConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTurbidityConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TurbidityConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTurbidityConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readTurbidityConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTurbidityConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.TurbidityConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTurbidityConcentrationMeasurementClusterEventListAttributeCallback(), + readTurbidityConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readTurbidityConcentrationMeasurementEventListAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.TurbidityConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTurbidityConcentrationMeasurementClusterAttributeListAttributeCallback(), + readTurbidityConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTurbidityConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTurbidityConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTurbidityConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readTurbidityConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTurbidityConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TurbidityConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTurbidityConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTurbidityConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readCopperConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readCopperConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.CopperConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCopperConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readCopperConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readCopperConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readCopperConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.CopperConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCopperConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readCopperConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readCopperConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readCopperConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.CopperConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCopperConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readCopperConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readCopperConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readCopperConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.CopperConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCopperConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readCopperConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readCopperConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readCopperConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCopperConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readCopperConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readCopperConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.CopperConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCopperConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readCopperConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readCopperConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readCopperConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCopperConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readCopperConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readCopperConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readCopperConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readCopperConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readCopperConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCopperConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readCopperConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readCopperConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCopperConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readCopperConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readCopperConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCopperConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readCopperConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readCopperConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.CopperConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCopperConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readCopperConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readCopperConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readCopperConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.CopperConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCopperConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readCopperConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readCopperConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readCopperConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.CopperConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCopperConcentrationMeasurementClusterEventListAttributeCallback(), + readCopperConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readCopperConcentrationMeasurementEventListAttributeInteractionInfo); + Map readCopperConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.CopperConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCopperConcentrationMeasurementClusterAttributeListAttributeCallback(), + readCopperConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readCopperConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readCopperConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCopperConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readCopperConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readCopperConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readCopperConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CopperConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCopperConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readCopperConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readLeadConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readLeadConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.LeadConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLeadConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readLeadConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readLeadConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readLeadConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.LeadConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLeadConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readLeadConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readLeadConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readLeadConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.LeadConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLeadConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readLeadConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readLeadConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readLeadConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.LeadConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLeadConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readLeadConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readLeadConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readLeadConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readLeadConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readLeadConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readLeadConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.LeadConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLeadConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readLeadConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readLeadConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readLeadConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readLeadConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readLeadConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readLeadConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readLeadConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readLeadConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readLeadConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLeadConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readLeadConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readLeadConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLeadConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readLeadConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readLeadConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLeadConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readLeadConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readLeadConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.LeadConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLeadConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readLeadConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readLeadConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readLeadConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.LeadConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLeadConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readLeadConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readLeadConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readLeadConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.LeadConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLeadConcentrationMeasurementClusterEventListAttributeCallback(), + readLeadConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readLeadConcentrationMeasurementEventListAttributeInteractionInfo); + Map readLeadConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.LeadConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLeadConcentrationMeasurementClusterAttributeListAttributeCallback(), + readLeadConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readLeadConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readLeadConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readLeadConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readLeadConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readLeadConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readLeadConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LeadConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLeadConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readLeadConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readManganeseConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readManganeseConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.ManganeseConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedManganeseConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readManganeseConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readManganeseConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.ManganeseConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedManganeseConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readManganeseConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readManganeseConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.ManganeseConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedManganeseConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readManganeseConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readManganeseConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.ManganeseConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedManganeseConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readManganeseConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readManganeseConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readManganeseConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readManganeseConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.ManganeseConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedManganeseConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readManganeseConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readManganeseConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readManganeseConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readManganeseConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readManganeseConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readManganeseConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readManganeseConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readManganeseConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readManganeseConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readManganeseConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readManganeseConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readManganeseConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ManganeseConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedManganeseConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readManganeseConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readManganeseConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ManganeseConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedManganeseConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readManganeseConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readManganeseConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.ManganeseConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedManganeseConcentrationMeasurementClusterEventListAttributeCallback(), + readManganeseConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readManganeseConcentrationMeasurementEventListAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.ManganeseConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedManganeseConcentrationMeasurementClusterAttributeListAttributeCallback(), + readManganeseConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readManganeseConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readManganeseConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readManganeseConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readManganeseConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readManganeseConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ManganeseConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readManganeseConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readManganeseConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readSulfateConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readSulfateConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.SulfateConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfateConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readSulfateConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readSulfateConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.SulfateConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfateConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readSulfateConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readSulfateConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.SulfateConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfateConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readSulfateConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readSulfateConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.SulfateConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfateConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readSulfateConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readSulfateConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSulfateConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readSulfateConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.SulfateConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfateConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readSulfateConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readSulfateConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSulfateConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readSulfateConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readSulfateConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readSulfateConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSulfateConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readSulfateConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSulfateConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readSulfateConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSulfateConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readSulfateConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.SulfateConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfateConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readSulfateConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readSulfateConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.SulfateConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfateConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readSulfateConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readSulfateConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.SulfateConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfateConcentrationMeasurementClusterEventListAttributeCallback(), + readSulfateConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readSulfateConcentrationMeasurementEventListAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.SulfateConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSulfateConcentrationMeasurementClusterAttributeListAttributeCallback(), + readSulfateConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readSulfateConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSulfateConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readSulfateConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readSulfateConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readSulfateConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SulfateConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSulfateConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readSulfateConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBromodichloromethaneConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBromodichloromethaneConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.BromodichloromethaneConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromodichloromethaneConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readBromodichloromethaneConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.BromodichloromethaneConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromodichloromethaneConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readBromodichloromethaneConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.BromodichloromethaneConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromodichloromethaneConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readBromodichloromethaneConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.BromodichloromethaneConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromodichloromethaneConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readBromodichloromethaneConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readBromodichloromethaneConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.BromodichloromethaneConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromodichloromethaneConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readBromodichloromethaneConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readBromodichloromethaneConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readBromodichloromethaneConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readBromodichloromethaneConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readBromodichloromethaneConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readBromodichloromethaneConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BromodichloromethaneConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromodichloromethaneConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBromodichloromethaneConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BromodichloromethaneConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromodichloromethaneConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBromodichloromethaneConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.BromodichloromethaneConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromodichloromethaneConcentrationMeasurementClusterEventListAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readBromodichloromethaneConcentrationMeasurementEventListAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.BromodichloromethaneConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromodichloromethaneConcentrationMeasurementClusterAttributeListAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBromodichloromethaneConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBromodichloromethaneConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readBromodichloromethaneConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBromodichloromethaneConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromodichloromethaneConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromodichloromethaneConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBromodichloromethaneConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBromoformConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBromoformConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.BromoformConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromoformConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readBromoformConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readBromoformConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.BromoformConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromoformConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readBromoformConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readBromoformConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.BromoformConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromoformConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readBromoformConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readBromoformConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.BromoformConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromoformConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readBromoformConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readBromoformConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBromoformConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readBromoformConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.BromoformConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromoformConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readBromoformConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readBromoformConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBromoformConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readBromoformConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readBromoformConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readBromoformConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromoformConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readBromoformConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromoformConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readBromoformConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromoformConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readBromoformConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BromoformConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromoformConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readBromoformConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBromoformConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BromoformConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromoformConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readBromoformConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBromoformConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.BromoformConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromoformConcentrationMeasurementClusterEventListAttributeCallback(), + readBromoformConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readBromoformConcentrationMeasurementEventListAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.BromoformConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBromoformConcentrationMeasurementClusterAttributeListAttributeCallback(), + readBromoformConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBromoformConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBromoformConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBromoformConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readBromoformConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBromoformConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BromoformConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBromoformConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBromoformConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readChlorodibromomethaneConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readChlorodibromomethaneConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorodibromomethaneConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readChlorodibromomethaneConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorodibromomethaneConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readChlorodibromomethaneConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorodibromomethaneConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readChlorodibromomethaneConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorodibromomethaneConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readChlorodibromomethaneConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readChlorodibromomethaneConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorodibromomethaneConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readChlorodibromomethaneConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readChlorodibromomethaneConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readChlorodibromomethaneConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readChlorodibromomethaneConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readChlorodibromomethaneConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readChlorodibromomethaneConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorodibromomethaneConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readChlorodibromomethaneConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorodibromomethaneConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readChlorodibromomethaneConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorodibromomethaneConcentrationMeasurementClusterEventListAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readChlorodibromomethaneConcentrationMeasurementEventListAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChlorodibromomethaneConcentrationMeasurementClusterAttributeListAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readChlorodibromomethaneConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readChlorodibromomethaneConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readChlorodibromomethaneConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readChlorodibromomethaneConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChlorodibromomethaneConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChlorodibromomethaneConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readChlorodibromomethaneConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readChloroformConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readChloroformConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.ChloroformConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloroformConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readChloroformConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readChloroformConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.ChloroformConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloroformConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readChloroformConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readChloroformConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.ChloroformConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloroformConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readChloroformConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readChloroformConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.ChloroformConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloroformConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readChloroformConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readChloroformConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChloroformConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readChloroformConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.ChloroformConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloroformConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readChloroformConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readChloroformConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChloroformConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readChloroformConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readChloroformConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readChloroformConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChloroformConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readChloroformConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChloroformConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readChloroformConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChloroformConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readChloroformConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ChloroformConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloroformConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readChloroformConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readChloroformConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ChloroformConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloroformConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readChloroformConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readChloroformConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.ChloroformConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloroformConcentrationMeasurementClusterEventListAttributeCallback(), + readChloroformConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readChloroformConcentrationMeasurementEventListAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.ChloroformConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChloroformConcentrationMeasurementClusterAttributeListAttributeCallback(), + readChloroformConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readChloroformConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChloroformConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readChloroformConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readChloroformConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readChloroformConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChloroformConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChloroformConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readChloroformConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readSodiumConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readSodiumConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.SodiumConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSodiumConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readSodiumConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readSodiumConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.SodiumConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSodiumConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readSodiumConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readSodiumConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.SodiumConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSodiumConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readSodiumConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readSodiumConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.SodiumConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSodiumConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readSodiumConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readSodiumConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSodiumConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readSodiumConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.SodiumConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSodiumConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readSodiumConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readSodiumConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSodiumConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readSodiumConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readSodiumConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readSodiumConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSodiumConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readSodiumConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSodiumConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readSodiumConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSodiumConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readSodiumConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.SodiumConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSodiumConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readSodiumConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readSodiumConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.SodiumConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSodiumConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readSodiumConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readSodiumConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.SodiumConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSodiumConcentrationMeasurementClusterEventListAttributeCallback(), + readSodiumConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readSodiumConcentrationMeasurementEventListAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.SodiumConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSodiumConcentrationMeasurementClusterAttributeListAttributeCallback(), + readSodiumConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readSodiumConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSodiumConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readSodiumConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readSodiumConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readSodiumConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SodiumConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSodiumConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readSodiumConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readPm25ConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readPm25ConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.Pm25ConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm25ConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readPm25ConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readPm25ConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.Pm25ConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm25ConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readPm25ConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readPm25ConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.Pm25ConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm25ConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readPm25ConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readPm25ConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.Pm25ConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm25ConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readPm25ConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readPm25ConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPm25ConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readPm25ConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.Pm25ConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm25ConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readPm25ConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readPm25ConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPm25ConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readPm25ConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readPm25ConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readPm25ConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm25ConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readPm25ConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm25ConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readPm25ConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm25ConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readPm25ConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.Pm25ConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm25ConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readPm25ConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readPm25ConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.Pm25ConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm25ConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readPm25ConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readPm25ConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.Pm25ConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm25ConcentrationMeasurementClusterEventListAttributeCallback(), + readPm25ConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readPm25ConcentrationMeasurementEventListAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.Pm25ConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm25ConcentrationMeasurementClusterAttributeListAttributeCallback(), + readPm25ConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readPm25ConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPm25ConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readPm25ConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readPm25ConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPm25ConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm25ConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm25ConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readPm25ConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readFormaldehydeConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readFormaldehydeConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.FormaldehydeConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFormaldehydeConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readFormaldehydeConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readFormaldehydeConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.FormaldehydeConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFormaldehydeConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readFormaldehydeConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.FormaldehydeConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFormaldehydeConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readFormaldehydeConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.FormaldehydeConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFormaldehydeConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readFormaldehydeConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFormaldehydeConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readFormaldehydeConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.FormaldehydeConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFormaldehydeConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readFormaldehydeConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFormaldehydeConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readFormaldehydeConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readFormaldehydeConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readFormaldehydeConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFormaldehydeConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readFormaldehydeConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFormaldehydeConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readFormaldehydeConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFormaldehydeConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readFormaldehydeConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.FormaldehydeConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFormaldehydeConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readFormaldehydeConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.FormaldehydeConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFormaldehydeConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readFormaldehydeConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.FormaldehydeConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFormaldehydeConcentrationMeasurementClusterEventListAttributeCallback(), + readFormaldehydeConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readFormaldehydeConcentrationMeasurementEventListAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.FormaldehydeConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFormaldehydeConcentrationMeasurementClusterAttributeListAttributeCallback(), + readFormaldehydeConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readFormaldehydeConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFormaldehydeConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readFormaldehydeConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readFormaldehydeConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFormaldehydeConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FormaldehydeConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFormaldehydeConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readFormaldehydeConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readPm1ConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readPm1ConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.Pm1ConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm1ConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readPm1ConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readPm1ConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.Pm1ConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm1ConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readPm1ConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readPm1ConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.Pm1ConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm1ConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readPm1ConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readPm1ConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.Pm1ConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm1ConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readPm1ConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readPm1ConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPm1ConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readPm1ConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.Pm1ConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm1ConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readPm1ConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readPm1ConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPm1ConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readPm1ConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readPm1ConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readPm1ConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm1ConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readPm1ConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm1ConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readPm1ConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm1ConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readPm1ConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.Pm1ConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm1ConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readPm1ConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readPm1ConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.Pm1ConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm1ConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readPm1ConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readPm1ConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.Pm1ConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm1ConcentrationMeasurementClusterEventListAttributeCallback(), + readPm1ConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readPm1ConcentrationMeasurementEventListAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.Pm1ConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm1ConcentrationMeasurementClusterAttributeListAttributeCallback(), + readPm1ConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readPm1ConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPm1ConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readPm1ConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readPm1ConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPm1ConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm1ConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm1ConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readPm1ConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readPm10ConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readPm10ConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.Pm10ConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm10ConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readPm10ConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readPm10ConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.Pm10ConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm10ConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readPm10ConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readPm10ConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.Pm10ConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm10ConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readPm10ConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readPm10ConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.Pm10ConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm10ConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readPm10ConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readPm10ConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPm10ConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readPm10ConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.Pm10ConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm10ConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readPm10ConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readPm10ConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPm10ConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readPm10ConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readPm10ConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readPm10ConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm10ConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readPm10ConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm10ConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readPm10ConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm10ConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readPm10ConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.Pm10ConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm10ConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readPm10ConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readPm10ConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.Pm10ConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm10ConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readPm10ConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readPm10ConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.Pm10ConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm10ConcentrationMeasurementClusterEventListAttributeCallback(), + readPm10ConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readPm10ConcentrationMeasurementEventListAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.Pm10ConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPm10ConcentrationMeasurementClusterAttributeListAttributeCallback(), + readPm10ConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readPm10ConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPm10ConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readPm10ConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readPm10ConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPm10ConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.Pm10ConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPm10ConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readPm10ConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTotalVolatileOrganicCompoundsConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalVolatileOrganicCompoundsConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalVolatileOrganicCompoundsConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalVolatileOrganicCompoundsConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalVolatileOrganicCompoundsConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalVolatileOrganicCompoundsConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalVolatileOrganicCompoundsConcentrationMeasurementClusterEventListAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAttributeListAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readTotalVolatileOrganicCompoundsConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTotalVolatileOrganicCompoundsConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TotalVolatileOrganicCompoundsConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTotalVolatileOrganicCompoundsConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTotalVolatileOrganicCompoundsConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readRadonConcentrationMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readRadonConcentrationMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.RadonConcentrationMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRadonConcentrationMeasurementClusterMeasuredValueAttributeCallback(), + readRadonConcentrationMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readRadonConcentrationMeasurementMeasuredValueAttributeInteractionInfo); + Map readRadonConcentrationMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.RadonConcentrationMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRadonConcentrationMeasurementClusterMinMeasuredValueAttributeCallback(), + readRadonConcentrationMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readRadonConcentrationMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readRadonConcentrationMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.RadonConcentrationMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRadonConcentrationMeasurementClusterMaxMeasuredValueAttributeCallback(), + readRadonConcentrationMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readRadonConcentrationMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readRadonConcentrationMeasurementPeakMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readPeakMeasuredValueAttribute( + (ChipClusters.RadonConcentrationMeasurementCluster.PeakMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRadonConcentrationMeasurementClusterPeakMeasuredValueAttributeCallback(), + readRadonConcentrationMeasurementPeakMeasuredValueCommandParams + ); + result.put("readPeakMeasuredValueAttribute", readRadonConcentrationMeasurementPeakMeasuredValueAttributeInteractionInfo); + Map readRadonConcentrationMeasurementPeakMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readPeakMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRadonConcentrationMeasurementPeakMeasuredValueWindowCommandParams + ); + result.put("readPeakMeasuredValueWindowAttribute", readRadonConcentrationMeasurementPeakMeasuredValueWindowAttributeInteractionInfo); + Map readRadonConcentrationMeasurementAverageMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readAverageMeasuredValueAttribute( + (ChipClusters.RadonConcentrationMeasurementCluster.AverageMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRadonConcentrationMeasurementClusterAverageMeasuredValueAttributeCallback(), + readRadonConcentrationMeasurementAverageMeasuredValueCommandParams + ); + result.put("readAverageMeasuredValueAttribute", readRadonConcentrationMeasurementAverageMeasuredValueAttributeInteractionInfo); + Map readRadonConcentrationMeasurementAverageMeasuredValueWindowCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readAverageMeasuredValueWindowAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRadonConcentrationMeasurementAverageMeasuredValueWindowCommandParams + ); + result.put("readAverageMeasuredValueWindowAttribute", readRadonConcentrationMeasurementAverageMeasuredValueWindowAttributeInteractionInfo); + Map readRadonConcentrationMeasurementUncertaintyCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementUncertaintyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readUncertaintyAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readRadonConcentrationMeasurementUncertaintyCommandParams + ); + result.put("readUncertaintyAttribute", readRadonConcentrationMeasurementUncertaintyAttributeInteractionInfo); + Map readRadonConcentrationMeasurementMeasurementUnitCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementMeasurementUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readMeasurementUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRadonConcentrationMeasurementMeasurementUnitCommandParams + ); + result.put("readMeasurementUnitAttribute", readRadonConcentrationMeasurementMeasurementUnitAttributeInteractionInfo); + Map readRadonConcentrationMeasurementMeasurementMediumCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementMeasurementMediumAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readMeasurementMediumAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRadonConcentrationMeasurementMeasurementMediumCommandParams + ); + result.put("readMeasurementMediumAttribute", readRadonConcentrationMeasurementMeasurementMediumAttributeInteractionInfo); + Map readRadonConcentrationMeasurementLevelValueCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementLevelValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readLevelValueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRadonConcentrationMeasurementLevelValueCommandParams + ); + result.put("readLevelValueAttribute", readRadonConcentrationMeasurementLevelValueAttributeInteractionInfo); + Map readRadonConcentrationMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.RadonConcentrationMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRadonConcentrationMeasurementClusterGeneratedCommandListAttributeCallback(), + readRadonConcentrationMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readRadonConcentrationMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readRadonConcentrationMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.RadonConcentrationMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRadonConcentrationMeasurementClusterAcceptedCommandListAttributeCallback(), + readRadonConcentrationMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readRadonConcentrationMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readRadonConcentrationMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.RadonConcentrationMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRadonConcentrationMeasurementClusterEventListAttributeCallback(), + readRadonConcentrationMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readRadonConcentrationMeasurementEventListAttributeInteractionInfo); + Map readRadonConcentrationMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.RadonConcentrationMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRadonConcentrationMeasurementClusterAttributeListAttributeCallback(), + readRadonConcentrationMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readRadonConcentrationMeasurementAttributeListAttributeInteractionInfo); + Map readRadonConcentrationMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRadonConcentrationMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readRadonConcentrationMeasurementFeatureMapAttributeInteractionInfo); + Map readRadonConcentrationMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readRadonConcentrationMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RadonConcentrationMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRadonConcentrationMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readRadonConcentrationMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } private static Map readWakeOnLanInteractionInfo() { Map result = new LinkedHashMap<>();Map readWakeOnLanMACAddressCommandParams = new LinkedHashMap(); InteractionInfo readWakeOnLanMACAddressAttributeInteractionInfo = new InteractionInfo( @@ -15491,6 +22367,42 @@ public Map> getReadAttributeMap() { put("flowMeasurement", readFlowMeasurementInteractionInfo()); put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo()); put("occupancySensing", readOccupancySensingInteractionInfo()); + put("carbonMonoxideConcentrationMeasurement", readCarbonMonoxideConcentrationMeasurementInteractionInfo()); + put("carbonDioxideConcentrationMeasurement", readCarbonDioxideConcentrationMeasurementInteractionInfo()); + put("ethyleneConcentrationMeasurement", readEthyleneConcentrationMeasurementInteractionInfo()); + put("ethyleneOxideConcentrationMeasurement", readEthyleneOxideConcentrationMeasurementInteractionInfo()); + put("hydrogenConcentrationMeasurement", readHydrogenConcentrationMeasurementInteractionInfo()); + put("hydrogenSulfideConcentrationMeasurement", readHydrogenSulfideConcentrationMeasurementInteractionInfo()); + put("nitricOxideConcentrationMeasurement", readNitricOxideConcentrationMeasurementInteractionInfo()); + put("nitrogenDioxideConcentrationMeasurement", readNitrogenDioxideConcentrationMeasurementInteractionInfo()); + put("oxygenConcentrationMeasurement", readOxygenConcentrationMeasurementInteractionInfo()); + put("ozoneConcentrationMeasurement", readOzoneConcentrationMeasurementInteractionInfo()); + put("sulfurDioxideConcentrationMeasurement", readSulfurDioxideConcentrationMeasurementInteractionInfo()); + put("dissolvedOxygenConcentrationMeasurement", readDissolvedOxygenConcentrationMeasurementInteractionInfo()); + put("bromateConcentrationMeasurement", readBromateConcentrationMeasurementInteractionInfo()); + put("chloraminesConcentrationMeasurement", readChloraminesConcentrationMeasurementInteractionInfo()); + put("chlorineConcentrationMeasurement", readChlorineConcentrationMeasurementInteractionInfo()); + put("fecalColiformEColiConcentrationMeasurement", readFecalColiformEColiConcentrationMeasurementInteractionInfo()); + put("fluorideConcentrationMeasurement", readFluorideConcentrationMeasurementInteractionInfo()); + put("haloaceticAcidsConcentrationMeasurement", readHaloaceticAcidsConcentrationMeasurementInteractionInfo()); + put("totalTrihalomethanesConcentrationMeasurement", readTotalTrihalomethanesConcentrationMeasurementInteractionInfo()); + put("totalColiformBacteriaConcentrationMeasurement", readTotalColiformBacteriaConcentrationMeasurementInteractionInfo()); + put("turbidityConcentrationMeasurement", readTurbidityConcentrationMeasurementInteractionInfo()); + put("copperConcentrationMeasurement", readCopperConcentrationMeasurementInteractionInfo()); + put("leadConcentrationMeasurement", readLeadConcentrationMeasurementInteractionInfo()); + put("manganeseConcentrationMeasurement", readManganeseConcentrationMeasurementInteractionInfo()); + put("sulfateConcentrationMeasurement", readSulfateConcentrationMeasurementInteractionInfo()); + put("bromodichloromethaneConcentrationMeasurement", readBromodichloromethaneConcentrationMeasurementInteractionInfo()); + put("bromoformConcentrationMeasurement", readBromoformConcentrationMeasurementInteractionInfo()); + put("chlorodibromomethaneConcentrationMeasurement", readChlorodibromomethaneConcentrationMeasurementInteractionInfo()); + put("chloroformConcentrationMeasurement", readChloroformConcentrationMeasurementInteractionInfo()); + put("sodiumConcentrationMeasurement", readSodiumConcentrationMeasurementInteractionInfo()); + put("pm25ConcentrationMeasurement", readPm25ConcentrationMeasurementInteractionInfo()); + put("formaldehydeConcentrationMeasurement", readFormaldehydeConcentrationMeasurementInteractionInfo()); + put("pm1ConcentrationMeasurement", readPm1ConcentrationMeasurementInteractionInfo()); + put("pm10ConcentrationMeasurement", readPm10ConcentrationMeasurementInteractionInfo()); + put("totalVolatileOrganicCompoundsConcentrationMeasurement", readTotalVolatileOrganicCompoundsConcentrationMeasurementInteractionInfo()); + put("radonConcentrationMeasurement", readRadonConcentrationMeasurementInteractionInfo()); put("wakeOnLan", readWakeOnLanInteractionInfo()); put("channel", readChannelInteractionInfo()); put("targetNavigator", readTargetNavigatorInteractionInfo()); diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java index d2ae0f2e2cf76a..00415b04a17648 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java @@ -3010,169 +3010,78 @@ public Map> getWriteAttributeMap() { ); writeOccupancySensingInteractionInfo.put("writePhysicalContactUnoccupiedToOccupiedThresholdAttribute", writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo); writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); - Map writeCarbonMonoxideConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "carbonMonoxideConcentrationMeasurement", - writeCarbonMonoxideConcentrationMeasurementInteractionInfo); - Map writeCarbonDioxideConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "carbonDioxideConcentrationMeasurement", - writeCarbonDioxideConcentrationMeasurementInteractionInfo); - Map writeEthyleneConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "ethyleneConcentrationMeasurement", writeEthyleneConcentrationMeasurementInteractionInfo); - Map writeEthyleneOxideConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "ethyleneOxideConcentrationMeasurement", - writeEthyleneOxideConcentrationMeasurementInteractionInfo); - Map writeHydrogenConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "hydrogenConcentrationMeasurement", writeHydrogenConcentrationMeasurementInteractionInfo); - Map writeHydrogenSulfideConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "hydrogenSulfideConcentrationMeasurement", - writeHydrogenSulfideConcentrationMeasurementInteractionInfo); - Map writeNitricOxideConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "nitricOxideConcentrationMeasurement", - writeNitricOxideConcentrationMeasurementInteractionInfo); - Map writeNitrogenDioxideConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "nitrogenDioxideConcentrationMeasurement", - writeNitrogenDioxideConcentrationMeasurementInteractionInfo); - Map writeOxygenConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "oxygenConcentrationMeasurement", writeOxygenConcentrationMeasurementInteractionInfo); - Map writeOzoneConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "ozoneConcentrationMeasurement", writeOzoneConcentrationMeasurementInteractionInfo); - Map writeSulfurDioxideConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "sulfurDioxideConcentrationMeasurement", - writeSulfurDioxideConcentrationMeasurementInteractionInfo); - Map writeDissolvedOxygenConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "dissolvedOxygenConcentrationMeasurement", - writeDissolvedOxygenConcentrationMeasurementInteractionInfo); - Map writeBromateConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "bromateConcentrationMeasurement", writeBromateConcentrationMeasurementInteractionInfo); - Map writeChloraminesConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "chloraminesConcentrationMeasurement", - writeChloraminesConcentrationMeasurementInteractionInfo); - Map writeChlorineConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "chlorineConcentrationMeasurement", writeChlorineConcentrationMeasurementInteractionInfo); - Map writeFecalColiformEColiConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "fecalColiformEColiConcentrationMeasurement", - writeFecalColiformEColiConcentrationMeasurementInteractionInfo); - Map writeFluorideConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "fluorideConcentrationMeasurement", writeFluorideConcentrationMeasurementInteractionInfo); - Map writeHaloaceticAcidsConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "haloaceticAcidsConcentrationMeasurement", - writeHaloaceticAcidsConcentrationMeasurementInteractionInfo); - Map writeTotalTrihalomethanesConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "totalTrihalomethanesConcentrationMeasurement", - writeTotalTrihalomethanesConcentrationMeasurementInteractionInfo); - Map writeTotalColiformBacteriaConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "totalColiformBacteriaConcentrationMeasurement", - writeTotalColiformBacteriaConcentrationMeasurementInteractionInfo); - Map writeTurbidityConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "turbidityConcentrationMeasurement", writeTurbidityConcentrationMeasurementInteractionInfo); - Map writeCopperConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "copperConcentrationMeasurement", writeCopperConcentrationMeasurementInteractionInfo); - Map writeLeadConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "leadConcentrationMeasurement", writeLeadConcentrationMeasurementInteractionInfo); - Map writeManganeseConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "manganeseConcentrationMeasurement", writeManganeseConcentrationMeasurementInteractionInfo); - Map writeSulfateConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "sulfateConcentrationMeasurement", writeSulfateConcentrationMeasurementInteractionInfo); - Map writeBromodichloromethaneConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "bromodichloromethaneConcentrationMeasurement", - writeBromodichloromethaneConcentrationMeasurementInteractionInfo); - Map writeBromoformConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "bromoformConcentrationMeasurement", writeBromoformConcentrationMeasurementInteractionInfo); - Map writeChlorodibromomethaneConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "chlorodibromomethaneConcentrationMeasurement", - writeChlorodibromomethaneConcentrationMeasurementInteractionInfo); - Map writeChloroformConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "chloroformConcentrationMeasurement", - writeChloroformConcentrationMeasurementInteractionInfo); - Map writeSodiumConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "sodiumConcentrationMeasurement", writeSodiumConcentrationMeasurementInteractionInfo); - Map writePm25ConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "pm25ConcentrationMeasurement", writePm25ConcentrationMeasurementInteractionInfo); - Map writeFormaldehydeConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "formaldehydeConcentrationMeasurement", - writeFormaldehydeConcentrationMeasurementInteractionInfo); - Map writePm1ConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "pm1ConcentrationMeasurement", writePm1ConcentrationMeasurementInteractionInfo); - Map writePm10ConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "pm10ConcentrationMeasurement", writePm10ConcentrationMeasurementInteractionInfo); - Map - writeTotalVolatileOrganicCompoundsConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "totalVolatileOrganicCompoundsConcentrationMeasurement", - writeTotalVolatileOrganicCompoundsConcentrationMeasurementInteractionInfo); - Map writeRadonConcentrationMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "radonConcentrationMeasurement", writeRadonConcentrationMeasurementInteractionInfo); + Map writeCarbonMonoxideConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("carbonMonoxideConcentrationMeasurement", writeCarbonMonoxideConcentrationMeasurementInteractionInfo); + Map writeCarbonDioxideConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("carbonDioxideConcentrationMeasurement", writeCarbonDioxideConcentrationMeasurementInteractionInfo); + Map writeEthyleneConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("ethyleneConcentrationMeasurement", writeEthyleneConcentrationMeasurementInteractionInfo); + Map writeEthyleneOxideConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("ethyleneOxideConcentrationMeasurement", writeEthyleneOxideConcentrationMeasurementInteractionInfo); + Map writeHydrogenConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("hydrogenConcentrationMeasurement", writeHydrogenConcentrationMeasurementInteractionInfo); + Map writeHydrogenSulfideConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("hydrogenSulfideConcentrationMeasurement", writeHydrogenSulfideConcentrationMeasurementInteractionInfo); + Map writeNitricOxideConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("nitricOxideConcentrationMeasurement", writeNitricOxideConcentrationMeasurementInteractionInfo); + Map writeNitrogenDioxideConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("nitrogenDioxideConcentrationMeasurement", writeNitrogenDioxideConcentrationMeasurementInteractionInfo); + Map writeOxygenConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("oxygenConcentrationMeasurement", writeOxygenConcentrationMeasurementInteractionInfo); + Map writeOzoneConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("ozoneConcentrationMeasurement", writeOzoneConcentrationMeasurementInteractionInfo); + Map writeSulfurDioxideConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("sulfurDioxideConcentrationMeasurement", writeSulfurDioxideConcentrationMeasurementInteractionInfo); + Map writeDissolvedOxygenConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("dissolvedOxygenConcentrationMeasurement", writeDissolvedOxygenConcentrationMeasurementInteractionInfo); + Map writeBromateConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bromateConcentrationMeasurement", writeBromateConcentrationMeasurementInteractionInfo); + Map writeChloraminesConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("chloraminesConcentrationMeasurement", writeChloraminesConcentrationMeasurementInteractionInfo); + Map writeChlorineConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("chlorineConcentrationMeasurement", writeChlorineConcentrationMeasurementInteractionInfo); + Map writeFecalColiformEColiConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("fecalColiformEColiConcentrationMeasurement", writeFecalColiformEColiConcentrationMeasurementInteractionInfo); + Map writeFluorideConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("fluorideConcentrationMeasurement", writeFluorideConcentrationMeasurementInteractionInfo); + Map writeHaloaceticAcidsConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("haloaceticAcidsConcentrationMeasurement", writeHaloaceticAcidsConcentrationMeasurementInteractionInfo); + Map writeTotalTrihalomethanesConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("totalTrihalomethanesConcentrationMeasurement", writeTotalTrihalomethanesConcentrationMeasurementInteractionInfo); + Map writeTotalColiformBacteriaConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("totalColiformBacteriaConcentrationMeasurement", writeTotalColiformBacteriaConcentrationMeasurementInteractionInfo); + Map writeTurbidityConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("turbidityConcentrationMeasurement", writeTurbidityConcentrationMeasurementInteractionInfo); + Map writeCopperConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("copperConcentrationMeasurement", writeCopperConcentrationMeasurementInteractionInfo); + Map writeLeadConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("leadConcentrationMeasurement", writeLeadConcentrationMeasurementInteractionInfo); + Map writeManganeseConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("manganeseConcentrationMeasurement", writeManganeseConcentrationMeasurementInteractionInfo); + Map writeSulfateConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("sulfateConcentrationMeasurement", writeSulfateConcentrationMeasurementInteractionInfo); + Map writeBromodichloromethaneConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bromodichloromethaneConcentrationMeasurement", writeBromodichloromethaneConcentrationMeasurementInteractionInfo); + Map writeBromoformConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bromoformConcentrationMeasurement", writeBromoformConcentrationMeasurementInteractionInfo); + Map writeChlorodibromomethaneConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("chlorodibromomethaneConcentrationMeasurement", writeChlorodibromomethaneConcentrationMeasurementInteractionInfo); + Map writeChloroformConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("chloroformConcentrationMeasurement", writeChloroformConcentrationMeasurementInteractionInfo); + Map writeSodiumConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("sodiumConcentrationMeasurement", writeSodiumConcentrationMeasurementInteractionInfo); + Map writePm25ConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("pm25ConcentrationMeasurement", writePm25ConcentrationMeasurementInteractionInfo); + Map writeFormaldehydeConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("formaldehydeConcentrationMeasurement", writeFormaldehydeConcentrationMeasurementInteractionInfo); + Map writePm1ConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("pm1ConcentrationMeasurement", writePm1ConcentrationMeasurementInteractionInfo); + Map writePm10ConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("pm10ConcentrationMeasurement", writePm10ConcentrationMeasurementInteractionInfo); + Map writeTotalVolatileOrganicCompoundsConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("totalVolatileOrganicCompoundsConcentrationMeasurement", writeTotalVolatileOrganicCompoundsConcentrationMeasurementInteractionInfo); + Map writeRadonConcentrationMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("radonConcentrationMeasurement", writeRadonConcentrationMeasurementInteractionInfo); Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); Map writeChannelInteractionInfo = new LinkedHashMap<>(); diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm index 0dce2a3abe0e0c..39d62ceb9389e5 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm @@ -3617,6 +3617,2166 @@ static BOOL AttributeIsSpecifiedInOccupancySensingCluster(AttributeId aAttribute } } } +static BOOL AttributeIsSpecifiedInCarbonMonoxideConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::CarbonMonoxideConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInCarbonDioxideConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::CarbonDioxideConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInEthyleneConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::EthyleneConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInEthyleneOxideConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::EthyleneOxideConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInHydrogenConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::HydrogenConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInHydrogenSulfideConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::HydrogenSulfideConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInNitricOxideConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::NitricOxideConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInNitrogenDioxideConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::NitrogenDioxideConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInOxygenConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::OxygenConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInOzoneConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::OzoneConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInSulfurDioxideConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::SulfurDioxideConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInDissolvedOxygenConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::DissolvedOxygenConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInBromateConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::BromateConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInChloraminesConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::ChloraminesConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInChlorineConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::ChlorineConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInFecalColiformEColiConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::FecalColiformEColiConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInFluorideConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::FluorideConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInHaloaceticAcidsConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::HaloaceticAcidsConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInTotalTrihalomethanesConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::TotalTrihalomethanesConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInTotalColiformBacteriaConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::TotalColiformBacteriaConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInTurbidityConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::TurbidityConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInCopperConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::CopperConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInLeadConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::LeadConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInManganeseConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::ManganeseConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInSulfateConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::SulfateConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInBromodichloromethaneConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::BromodichloromethaneConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInBromoformConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::BromoformConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInChlorodibromomethaneConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::ChlorodibromomethaneConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInChloroformConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::ChloroformConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInSodiumConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::SodiumConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInPM25ConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::Pm25ConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInFormaldehydeConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::FormaldehydeConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInPM1ConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::Pm1ConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInPM10ConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::Pm10ConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInTotalVolatileOrganicCompoundsConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInRadonConcentrationMeasurementCluster(AttributeId aAttributeId) +{ + using namespace Clusters::RadonConcentrationMeasurement; + switch (aAttributeId) { + case Attributes::MeasuredValue::Id: { + return YES; + } + case Attributes::MinMeasuredValue::Id: { + return YES; + } + case Attributes::MaxMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValue::Id: { + return YES; + } + case Attributes::PeakMeasuredValueWindow::Id: { + return YES; + } + case Attributes::AverageMeasuredValue::Id: { + return YES; + } + case Attributes::AverageMeasuredValueWindow::Id: { + return YES; + } + case Attributes::Uncertainty::Id: { + return YES; + } + case Attributes::MeasurementUnit::Id: { + return YES; + } + case Attributes::MeasurementMedium::Id: { + return YES; + } + case Attributes::LevelValue::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} static BOOL AttributeIsSpecifiedInWakeOnLANCluster(AttributeId aAttributeId) { using namespace Clusters::WakeOnLan; @@ -4917,6 +7077,114 @@ BOOL MTRAttributeIsSpecified(ClusterId aClusterId, AttributeId aAttributeId) case Clusters::OccupancySensing::Id: { return AttributeIsSpecifiedInOccupancySensingCluster(aAttributeId); } + case Clusters::CarbonMonoxideConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInCarbonMonoxideConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::CarbonDioxideConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInCarbonDioxideConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::EthyleneConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInEthyleneConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::EthyleneOxideConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInEthyleneOxideConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::HydrogenConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInHydrogenConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::HydrogenSulfideConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInHydrogenSulfideConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::NitricOxideConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInNitricOxideConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::NitrogenDioxideConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInNitrogenDioxideConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::OxygenConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInOxygenConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::OzoneConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInOzoneConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::SulfurDioxideConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInSulfurDioxideConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::DissolvedOxygenConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInDissolvedOxygenConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::BromateConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInBromateConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::ChloraminesConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInChloraminesConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::ChlorineConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInChlorineConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::FecalColiformEColiConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInFecalColiformEColiConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::FluorideConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInFluorideConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::HaloaceticAcidsConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInHaloaceticAcidsConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::TotalTrihalomethanesConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInTotalTrihalomethanesConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::TotalColiformBacteriaConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInTotalColiformBacteriaConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::TurbidityConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInTurbidityConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::CopperConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInCopperConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::LeadConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInLeadConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::ManganeseConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInManganeseConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::SulfateConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInSulfateConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::BromodichloromethaneConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInBromodichloromethaneConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::BromoformConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInBromoformConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::ChlorodibromomethaneConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInChlorodibromomethaneConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::ChloroformConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInChloroformConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::SodiumConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInSodiumConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::Pm25ConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInPM25ConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::FormaldehydeConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInFormaldehydeConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::Pm1ConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInPM1ConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::Pm10ConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInPM10ConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInTotalVolatileOrganicCompoundsConcentrationMeasurementCluster(aAttributeId); + } + case Clusters::RadonConcentrationMeasurement::Id: { + return AttributeIsSpecifiedInRadonConcentrationMeasurementCluster(aAttributeId); + } case Clusters::WakeOnLan::Id: { return AttributeIsSpecifiedInWakeOnLANCluster(aAttributeId); }