/src/connectedhomeip/zzz_generated/app-common/clusters/ElectricalAlarm/Attributes.h

Source
/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP
// This file is generated from clusters-Attributes.h.zapt

#pragma once

#include <app/ConcreteAttributePath.h>
#include <app/data-model/DecodableList.h>
#include <app/data-model/List.h>
#include <app/data-model/Nullable.h>
#include <app/util/basic-types.h>
#include <lib/core/TLV.h>
#include <lib/support/BitMask.h>

#include <clusters/shared/Attributes.h>
#include <clusters/shared/Enums.h>
#include <clusters/shared/Structs.h>

#include <clusters/ElectricalAlarm/AttributeIds.h>
#include <clusters/ElectricalAlarm/ClusterId.h>
#include <clusters/ElectricalAlarm/Enums.h>
#include <clusters/ElectricalAlarm/Structs.h>

namespace chip {
namespace app {
namespace Clusters {
namespace ElectricalAlarm {
namespace Attributes {

namespace Mask {
struct TypeInfo
{
    using Type             = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
    using DecodableType    = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
    using DecodableArgType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::Mask::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace Mask
namespace Latch {
struct TypeInfo
{
    using Type             = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
    using DecodableType    = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
    using DecodableArgType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::Latch::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace Latch
namespace State {
struct TypeInfo
{
    using Type             = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
    using DecodableType    = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
    using DecodableArgType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::State::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace State
namespace Supported {
struct TypeInfo
{
    using Type             = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
    using DecodableType    = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
    using DecodableArgType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::Supported::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace Supported
namespace OverVoltageThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::OverVoltageThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace OverVoltageThreshold
namespace UnderVoltageThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::UnderVoltageThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace UnderVoltageThreshold
namespace OverFrequencyThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::OverFrequencyThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace OverFrequencyThreshold
namespace UnderFrequencyThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::UnderFrequencyThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace UnderFrequencyThreshold
namespace OverPowerThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::OverPowerThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace OverPowerThreshold
namespace UnderPowerThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::UnderPowerThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace UnderPowerThreshold
namespace OverCurrentThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::OverCurrentThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace OverCurrentThreshold
namespace UnderCurrentThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::UnderCurrentThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace UnderCurrentThreshold
namespace PowerImportThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::PowerImportThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace PowerImportThreshold
namespace PowerExportThreshold {
struct TypeInfo
{
    using Type             = int64_t;
    using DecodableType    = int64_t;
    using DecodableArgType = int64_t;

    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::PowerExportThreshold::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace PowerExportThreshold
namespace GeneratedCommandList {
struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
{
    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
};
} // namespace GeneratedCommandList
namespace AcceptedCommandList {
struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
{
    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
};
} // namespace AcceptedCommandList
namespace AttributeList {
struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
{
    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
};
} // namespace AttributeList
namespace FeatureMap {
struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
{
    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
};
} // namespace FeatureMap
namespace ClusterRevision {
struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
{
    static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
};
} // namespace ClusterRevision

struct TypeInfo
{
    struct DecodableType
    {
        static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }

        CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);

        Attributes::Mask::TypeInfo::DecodableType mask =
            static_cast<chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>>(0);
        Attributes::Latch::TypeInfo::DecodableType latch =
            static_cast<chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>>(0);
        Attributes::State::TypeInfo::DecodableType state =
            static_cast<chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>>(0);
        Attributes::Supported::TypeInfo::DecodableType supported =
            static_cast<chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>>(0);
        Attributes::OverVoltageThreshold::TypeInfo::DecodableType overVoltageThreshold       = static_cast<int64_t>(0);
        Attributes::UnderVoltageThreshold::TypeInfo::DecodableType underVoltageThreshold     = static_cast<int64_t>(0);
        Attributes::OverFrequencyThreshold::TypeInfo::DecodableType overFrequencyThreshold   = static_cast<int64_t>(0);
        Attributes::UnderFrequencyThreshold::TypeInfo::DecodableType underFrequencyThreshold = static_cast<int64_t>(0);
        Attributes::OverPowerThreshold::TypeInfo::DecodableType overPowerThreshold           = static_cast<int64_t>(0);
        Attributes::UnderPowerThreshold::TypeInfo::DecodableType underPowerThreshold         = static_cast<int64_t>(0);
        Attributes::OverCurrentThreshold::TypeInfo::DecodableType overCurrentThreshold       = static_cast<int64_t>(0);
        Attributes::UnderCurrentThreshold::TypeInfo::DecodableType underCurrentThreshold     = static_cast<int64_t>(0);
        Attributes::PowerImportThreshold::TypeInfo::DecodableType powerImportThreshold       = static_cast<int64_t>(0);
        Attributes::PowerExportThreshold::TypeInfo::DecodableType powerExportThreshold       = static_cast<int64_t>(0);
        Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
        Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
        Attributes::AttributeList::TypeInfo::DecodableType attributeList;
        Attributes::FeatureMap::TypeInfo::DecodableType featureMap           = static_cast<uint32_t>(0);
        Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
    };
};
} // namespace Attributes
} // namespace ElectricalAlarm
} // namespace Clusters
} // namespace app
} // namespace chip

Coverage Report

Created: 2026-08-14 07:41

Line	Count	Source
1		/*
2		*
3		* Copyright (c) 2022 Project CHIP Authors
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17
18		// THIS FILE IS GENERATED BY ZAP
19		// This file is generated from clusters-Attributes.h.zapt
20
21		#pragma once
22
23		#include <app/ConcreteAttributePath.h>
24		#include <app/data-model/DecodableList.h>
25		#include <app/data-model/List.h>
26		#include <app/data-model/Nullable.h>
27		#include <app/util/basic-types.h>
28		#include <lib/core/TLV.h>
29		#include <lib/support/BitMask.h>
30
31		#include <clusters/shared/Attributes.h>
32		#include <clusters/shared/Enums.h>
33		#include <clusters/shared/Structs.h>
34
35		#include <clusters/ElectricalAlarm/AttributeIds.h>
36		#include <clusters/ElectricalAlarm/ClusterId.h>
37		#include <clusters/ElectricalAlarm/Enums.h>
38		#include <clusters/ElectricalAlarm/Structs.h>
39
40		namespace chip {
41		namespace app {
42		namespace Clusters {
43		namespace ElectricalAlarm {
44		namespace Attributes {
45
46		namespace Mask {
47		struct TypeInfo
48		{
49		using Type = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
50		using DecodableType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
51		using DecodableArgType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
52
53	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
54	0	static constexpr AttributeId GetAttributeId() { return Attributes::Mask::Id; }
55	0	static constexpr bool MustUseTimedWrite() { return false; }
56		};
57		} // namespace Mask
58		namespace Latch {
59		struct TypeInfo
60		{
61		using Type = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
62		using DecodableType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
63		using DecodableArgType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
64
65	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
66	0	static constexpr AttributeId GetAttributeId() { return Attributes::Latch::Id; }
67	0	static constexpr bool MustUseTimedWrite() { return false; }
68		};
69		} // namespace Latch
70		namespace State {
71		struct TypeInfo
72		{
73		using Type = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
74		using DecodableType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
75		using DecodableArgType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
76
77	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
78	0	static constexpr AttributeId GetAttributeId() { return Attributes::State::Id; }
79	0	static constexpr bool MustUseTimedWrite() { return false; }
80		};
81		} // namespace State
82		namespace Supported {
83		struct TypeInfo
84		{
85		using Type = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
86		using DecodableType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
87		using DecodableArgType = chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>;
88
89	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
90	0	static constexpr AttributeId GetAttributeId() { return Attributes::Supported::Id; }
91	0	static constexpr bool MustUseTimedWrite() { return false; }
92		};
93		} // namespace Supported
94		namespace OverVoltageThreshold {
95		struct TypeInfo
96		{
97		using Type = int64_t;
98		using DecodableType = int64_t;
99		using DecodableArgType = int64_t;
100
101	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
102	0	static constexpr AttributeId GetAttributeId() { return Attributes::OverVoltageThreshold::Id; }
103	0	static constexpr bool MustUseTimedWrite() { return false; }
104		};
105		} // namespace OverVoltageThreshold
106		namespace UnderVoltageThreshold {
107		struct TypeInfo
108		{
109		using Type = int64_t;
110		using DecodableType = int64_t;
111		using DecodableArgType = int64_t;
112
113	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
114	0	static constexpr AttributeId GetAttributeId() { return Attributes::UnderVoltageThreshold::Id; }
115	0	static constexpr bool MustUseTimedWrite() { return false; }
116		};
117		} // namespace UnderVoltageThreshold
118		namespace OverFrequencyThreshold {
119		struct TypeInfo
120		{
121		using Type = int64_t;
122		using DecodableType = int64_t;
123		using DecodableArgType = int64_t;
124
125	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
126	0	static constexpr AttributeId GetAttributeId() { return Attributes::OverFrequencyThreshold::Id; }
127	0	static constexpr bool MustUseTimedWrite() { return false; }
128		};
129		} // namespace OverFrequencyThreshold
130		namespace UnderFrequencyThreshold {
131		struct TypeInfo
132		{
133		using Type = int64_t;
134		using DecodableType = int64_t;
135		using DecodableArgType = int64_t;
136
137	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
138	0	static constexpr AttributeId GetAttributeId() { return Attributes::UnderFrequencyThreshold::Id; }
139	0	static constexpr bool MustUseTimedWrite() { return false; }
140		};
141		} // namespace UnderFrequencyThreshold
142		namespace OverPowerThreshold {
143		struct TypeInfo
144		{
145		using Type = int64_t;
146		using DecodableType = int64_t;
147		using DecodableArgType = int64_t;
148
149	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
150	0	static constexpr AttributeId GetAttributeId() { return Attributes::OverPowerThreshold::Id; }
151	0	static constexpr bool MustUseTimedWrite() { return false; }
152		};
153		} // namespace OverPowerThreshold
154		namespace UnderPowerThreshold {
155		struct TypeInfo
156		{
157		using Type = int64_t;
158		using DecodableType = int64_t;
159		using DecodableArgType = int64_t;
160
161	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
162	0	static constexpr AttributeId GetAttributeId() { return Attributes::UnderPowerThreshold::Id; }
163	0	static constexpr bool MustUseTimedWrite() { return false; }
164		};
165		} // namespace UnderPowerThreshold
166		namespace OverCurrentThreshold {
167		struct TypeInfo
168		{
169		using Type = int64_t;
170		using DecodableType = int64_t;
171		using DecodableArgType = int64_t;
172
173	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
174	0	static constexpr AttributeId GetAttributeId() { return Attributes::OverCurrentThreshold::Id; }
175	0	static constexpr bool MustUseTimedWrite() { return false; }
176		};
177		} // namespace OverCurrentThreshold
178		namespace UnderCurrentThreshold {
179		struct TypeInfo
180		{
181		using Type = int64_t;
182		using DecodableType = int64_t;
183		using DecodableArgType = int64_t;
184
185	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
186	0	static constexpr AttributeId GetAttributeId() { return Attributes::UnderCurrentThreshold::Id; }
187	0	static constexpr bool MustUseTimedWrite() { return false; }
188		};
189		} // namespace UnderCurrentThreshold
190		namespace PowerImportThreshold {
191		struct TypeInfo
192		{
193		using Type = int64_t;
194		using DecodableType = int64_t;
195		using DecodableArgType = int64_t;
196
197	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
198	0	static constexpr AttributeId GetAttributeId() { return Attributes::PowerImportThreshold::Id; }
199	0	static constexpr bool MustUseTimedWrite() { return false; }
200		};
201		} // namespace PowerImportThreshold
202		namespace PowerExportThreshold {
203		struct TypeInfo
204		{
205		using Type = int64_t;
206		using DecodableType = int64_t;
207		using DecodableArgType = int64_t;
208
209	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
210	0	static constexpr AttributeId GetAttributeId() { return Attributes::PowerExportThreshold::Id; }
211	0	static constexpr bool MustUseTimedWrite() { return false; }
212		};
213		} // namespace PowerExportThreshold
214		namespace GeneratedCommandList {
215		struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
216		{
217	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
218		};
219		} // namespace GeneratedCommandList
220		namespace AcceptedCommandList {
221		struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
222		{
223	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
224		};
225		} // namespace AcceptedCommandList
226		namespace AttributeList {
227		struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
228		{
229	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
230		};
231		} // namespace AttributeList
232		namespace FeatureMap {
233		struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
234		{
235	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
236		};
237		} // namespace FeatureMap
238		namespace ClusterRevision {
239		struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
240		{
241	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
242		};
243		} // namespace ClusterRevision
244
245		struct TypeInfo
246		{
247		struct DecodableType
248		{
249	0	static constexpr ClusterId GetClusterId() { return Clusters::ElectricalAlarm::Id; }
250
251		CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
252
253		Attributes::Mask::TypeInfo::DecodableType mask =
254		static_cast<chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>>(0);
255		Attributes::Latch::TypeInfo::DecodableType latch =
256		static_cast<chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>>(0);
257		Attributes::State::TypeInfo::DecodableType state =
258		static_cast<chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>>(0);
259		Attributes::Supported::TypeInfo::DecodableType supported =
260		static_cast<chip::BitMask<chip::app::Clusters::ElectricalAlarm::AlarmBitmap>>(0);
261		Attributes::OverVoltageThreshold::TypeInfo::DecodableType overVoltageThreshold = static_cast<int64_t>(0);
262		Attributes::UnderVoltageThreshold::TypeInfo::DecodableType underVoltageThreshold = static_cast<int64_t>(0);
263		Attributes::OverFrequencyThreshold::TypeInfo::DecodableType overFrequencyThreshold = static_cast<int64_t>(0);
264		Attributes::UnderFrequencyThreshold::TypeInfo::DecodableType underFrequencyThreshold = static_cast<int64_t>(0);
265		Attributes::OverPowerThreshold::TypeInfo::DecodableType overPowerThreshold = static_cast<int64_t>(0);
266		Attributes::UnderPowerThreshold::TypeInfo::DecodableType underPowerThreshold = static_cast<int64_t>(0);
267		Attributes::OverCurrentThreshold::TypeInfo::DecodableType overCurrentThreshold = static_cast<int64_t>(0);
268		Attributes::UnderCurrentThreshold::TypeInfo::DecodableType underCurrentThreshold = static_cast<int64_t>(0);
269		Attributes::PowerImportThreshold::TypeInfo::DecodableType powerImportThreshold = static_cast<int64_t>(0);
270		Attributes::PowerExportThreshold::TypeInfo::DecodableType powerExportThreshold = static_cast<int64_t>(0);
271		Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
272		Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
273		Attributes::AttributeList::TypeInfo::DecodableType attributeList;
274		Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
275		Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
276		};
277		};
278		} // namespace Attributes
279		} // namespace ElectricalAlarm
280		} // namespace Clusters
281		} // namespace app
282		} // namespace chip