/src/connectedhomeip/zzz_generated/app-common/clusters/SmokeCoAlarm/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/SmokeCoAlarm/AttributeIds.h>
#include <clusters/SmokeCoAlarm/ClusterId.h>
#include <clusters/SmokeCoAlarm/Enums.h>
#include <clusters/SmokeCoAlarm/Structs.h>

namespace chip {
namespace app {
namespace Clusters {
namespace SmokeCoAlarm {
namespace Attributes {

namespace ExpressedState {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::ExpressedState::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace ExpressedState
namespace SmokeState {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::SmokeState::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace SmokeState
namespace COState {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::COState::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace COState
namespace BatteryAlert {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::BatteryAlert::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace BatteryAlert
namespace DeviceMuted {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::MuteStateEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::MuteStateEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::MuteStateEnum;

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

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

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::HardwareFaultAlert::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace HardwareFaultAlert
namespace EndOfServiceAlert {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::EndOfServiceAlert::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace EndOfServiceAlert
namespace InterconnectSmokeAlarm {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::InterconnectSmokeAlarm::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace InterconnectSmokeAlarm
namespace InterconnectCOAlarm {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::InterconnectCOAlarm::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace InterconnectCOAlarm
namespace ContaminationState {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::ContaminationState::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace ContaminationState
namespace SmokeSensitivityLevel {
struct TypeInfo
{
    using Type             = chip::app::Clusters::SmokeCoAlarm::SensitivityEnum;
    using DecodableType    = chip::app::Clusters::SmokeCoAlarm::SensitivityEnum;
    using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::SensitivityEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::SmokeSensitivityLevel::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace SmokeSensitivityLevel
namespace ExpiryDate {
struct TypeInfo
{
    using Type             = uint32_t;
    using DecodableType    = uint32_t;
    using DecodableArgType = uint32_t;

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

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

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

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

        Attributes::ExpressedState::TypeInfo::DecodableType expressedState =
            static_cast<chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum>(0);
        Attributes::SmokeState::TypeInfo::DecodableType smokeState =
            static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
        Attributes::COState::TypeInfo::DecodableType COState = static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
        Attributes::BatteryAlert::TypeInfo::DecodableType batteryAlert =
            static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
        Attributes::DeviceMuted::TypeInfo::DecodableType deviceMuted =
            static_cast<chip::app::Clusters::SmokeCoAlarm::MuteStateEnum>(0);
        Attributes::TestInProgress::TypeInfo::DecodableType testInProgress         = static_cast<bool>(0);
        Attributes::HardwareFaultAlert::TypeInfo::DecodableType hardwareFaultAlert = static_cast<bool>(0);
        Attributes::EndOfServiceAlert::TypeInfo::DecodableType endOfServiceAlert =
            static_cast<chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum>(0);
        Attributes::InterconnectSmokeAlarm::TypeInfo::DecodableType interconnectSmokeAlarm =
            static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
        Attributes::InterconnectCOAlarm::TypeInfo::DecodableType interconnectCOAlarm =
            static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
        Attributes::ContaminationState::TypeInfo::DecodableType contaminationState =
            static_cast<chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum>(0);
        Attributes::SmokeSensitivityLevel::TypeInfo::DecodableType smokeSensitivityLevel =
            static_cast<chip::app::Clusters::SmokeCoAlarm::SensitivityEnum>(0);
        Attributes::ExpiryDate::TypeInfo::DecodableType expiryDate = static_cast<uint32_t>(0);
        Attributes::Unmounted::TypeInfo::DecodableType unmounted   = static_cast<bool>(0);
        Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
        Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
        Attributes::AttributeList::TypeInfo::DecodableType attributeList;
        Attributes::FeatureMap::TypeInfo::DecodableType featureMap           = static_cast<uint32_t>(0);
        Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
    };
};
} // namespace Attributes
} // namespace SmokeCoAlarm
} // namespace Clusters
} // namespace app
} // namespace chip

Coverage Report

Created: 2026-03-27 06:51

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/SmokeCoAlarm/AttributeIds.h>
36		#include <clusters/SmokeCoAlarm/ClusterId.h>
37		#include <clusters/SmokeCoAlarm/Enums.h>
38		#include <clusters/SmokeCoAlarm/Structs.h>
39
40		namespace chip {
41		namespace app {
42		namespace Clusters {
43		namespace SmokeCoAlarm {
44		namespace Attributes {
45
46		namespace ExpressedState {
47		struct TypeInfo
48		{
49		using Type = chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum;
50		using DecodableType = chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum;
51		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum;
52
53	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
54	0	static constexpr AttributeId GetAttributeId() { return Attributes::ExpressedState::Id; }
55	0	static constexpr bool MustUseTimedWrite() { return false; }
56		};
57		} // namespace ExpressedState
58		namespace SmokeState {
59		struct TypeInfo
60		{
61		using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
62		using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
63		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
64
65	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
66	0	static constexpr AttributeId GetAttributeId() { return Attributes::SmokeState::Id; }
67	0	static constexpr bool MustUseTimedWrite() { return false; }
68		};
69		} // namespace SmokeState
70		namespace COState {
71		struct TypeInfo
72		{
73		using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
74		using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
75		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
76
77	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
78	0	static constexpr AttributeId GetAttributeId() { return Attributes::COState::Id; }
79	0	static constexpr bool MustUseTimedWrite() { return false; }
80		};
81		} // namespace COState
82		namespace BatteryAlert {
83		struct TypeInfo
84		{
85		using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
86		using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
87		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
88
89	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
90	0	static constexpr AttributeId GetAttributeId() { return Attributes::BatteryAlert::Id; }
91	0	static constexpr bool MustUseTimedWrite() { return false; }
92		};
93		} // namespace BatteryAlert
94		namespace DeviceMuted {
95		struct TypeInfo
96		{
97		using Type = chip::app::Clusters::SmokeCoAlarm::MuteStateEnum;
98		using DecodableType = chip::app::Clusters::SmokeCoAlarm::MuteStateEnum;
99		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::MuteStateEnum;
100
101	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
102	0	static constexpr AttributeId GetAttributeId() { return Attributes::DeviceMuted::Id; }
103	0	static constexpr bool MustUseTimedWrite() { return false; }
104		};
105		} // namespace DeviceMuted
106		namespace TestInProgress {
107		struct TypeInfo
108		{
109		using Type = bool;
110		using DecodableType = bool;
111		using DecodableArgType = bool;
112
113	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
114	0	static constexpr AttributeId GetAttributeId() { return Attributes::TestInProgress::Id; }
115	0	static constexpr bool MustUseTimedWrite() { return false; }
116		};
117		} // namespace TestInProgress
118		namespace HardwareFaultAlert {
119		struct TypeInfo
120		{
121		using Type = bool;
122		using DecodableType = bool;
123		using DecodableArgType = bool;
124
125	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
126	0	static constexpr AttributeId GetAttributeId() { return Attributes::HardwareFaultAlert::Id; }
127	0	static constexpr bool MustUseTimedWrite() { return false; }
128		};
129		} // namespace HardwareFaultAlert
130		namespace EndOfServiceAlert {
131		struct TypeInfo
132		{
133		using Type = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum;
134		using DecodableType = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum;
135		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum;
136
137	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
138	0	static constexpr AttributeId GetAttributeId() { return Attributes::EndOfServiceAlert::Id; }
139	0	static constexpr bool MustUseTimedWrite() { return false; }
140		};
141		} // namespace EndOfServiceAlert
142		namespace InterconnectSmokeAlarm {
143		struct TypeInfo
144		{
145		using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
146		using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
147		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
148
149	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
150	0	static constexpr AttributeId GetAttributeId() { return Attributes::InterconnectSmokeAlarm::Id; }
151	0	static constexpr bool MustUseTimedWrite() { return false; }
152		};
153		} // namespace InterconnectSmokeAlarm
154		namespace InterconnectCOAlarm {
155		struct TypeInfo
156		{
157		using Type = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
158		using DecodableType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
159		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum;
160
161	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
162	0	static constexpr AttributeId GetAttributeId() { return Attributes::InterconnectCOAlarm::Id; }
163	0	static constexpr bool MustUseTimedWrite() { return false; }
164		};
165		} // namespace InterconnectCOAlarm
166		namespace ContaminationState {
167		struct TypeInfo
168		{
169		using Type = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum;
170		using DecodableType = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum;
171		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum;
172
173	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
174	0	static constexpr AttributeId GetAttributeId() { return Attributes::ContaminationState::Id; }
175	0	static constexpr bool MustUseTimedWrite() { return false; }
176		};
177		} // namespace ContaminationState
178		namespace SmokeSensitivityLevel {
179		struct TypeInfo
180		{
181		using Type = chip::app::Clusters::SmokeCoAlarm::SensitivityEnum;
182		using DecodableType = chip::app::Clusters::SmokeCoAlarm::SensitivityEnum;
183		using DecodableArgType = chip::app::Clusters::SmokeCoAlarm::SensitivityEnum;
184
185	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
186	0	static constexpr AttributeId GetAttributeId() { return Attributes::SmokeSensitivityLevel::Id; }
187	0	static constexpr bool MustUseTimedWrite() { return false; }
188		};
189		} // namespace SmokeSensitivityLevel
190		namespace ExpiryDate {
191		struct TypeInfo
192		{
193		using Type = uint32_t;
194		using DecodableType = uint32_t;
195		using DecodableArgType = uint32_t;
196
197	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
198	0	static constexpr AttributeId GetAttributeId() { return Attributes::ExpiryDate::Id; }
199	0	static constexpr bool MustUseTimedWrite() { return false; }
200		};
201		} // namespace ExpiryDate
202		namespace Unmounted {
203		struct TypeInfo
204		{
205		using Type = bool;
206		using DecodableType = bool;
207		using DecodableArgType = bool;
208
209	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
210	0	static constexpr AttributeId GetAttributeId() { return Attributes::Unmounted::Id; }
211	0	static constexpr bool MustUseTimedWrite() { return false; }
212		};
213		} // namespace Unmounted
214		namespace GeneratedCommandList {
215		struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
216		{
217	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::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::SmokeCoAlarm::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::SmokeCoAlarm::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::SmokeCoAlarm::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::SmokeCoAlarm::Id; }
242		};
243		} // namespace ClusterRevision
244
245		struct TypeInfo
246		{
247		struct DecodableType
248		{
249	0	static constexpr ClusterId GetClusterId() { return Clusters::SmokeCoAlarm::Id; }
250
251		CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
252
253		Attributes::ExpressedState::TypeInfo::DecodableType expressedState =
254		static_cast<chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum>(0);
255		Attributes::SmokeState::TypeInfo::DecodableType smokeState =
256		static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
257		Attributes::COState::TypeInfo::DecodableType COState = static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
258		Attributes::BatteryAlert::TypeInfo::DecodableType batteryAlert =
259		static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
260		Attributes::DeviceMuted::TypeInfo::DecodableType deviceMuted =
261		static_cast<chip::app::Clusters::SmokeCoAlarm::MuteStateEnum>(0);
262		Attributes::TestInProgress::TypeInfo::DecodableType testInProgress = static_cast<bool>(0);
263		Attributes::HardwareFaultAlert::TypeInfo::DecodableType hardwareFaultAlert = static_cast<bool>(0);
264		Attributes::EndOfServiceAlert::TypeInfo::DecodableType endOfServiceAlert =
265		static_cast<chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum>(0);
266		Attributes::InterconnectSmokeAlarm::TypeInfo::DecodableType interconnectSmokeAlarm =
267		static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
268		Attributes::InterconnectCOAlarm::TypeInfo::DecodableType interconnectCOAlarm =
269		static_cast<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>(0);
270		Attributes::ContaminationState::TypeInfo::DecodableType contaminationState =
271		static_cast<chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum>(0);
272		Attributes::SmokeSensitivityLevel::TypeInfo::DecodableType smokeSensitivityLevel =
273		static_cast<chip::app::Clusters::SmokeCoAlarm::SensitivityEnum>(0);
274		Attributes::ExpiryDate::TypeInfo::DecodableType expiryDate = static_cast<uint32_t>(0);
275		Attributes::Unmounted::TypeInfo::DecodableType unmounted = static_cast<bool>(0);
276		Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
277		Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
278		Attributes::AttributeList::TypeInfo::DecodableType attributeList;
279		Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
280		Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
281		};
282		};
283		} // namespace Attributes
284		} // namespace SmokeCoAlarm
285		} // namespace Clusters
286		} // namespace app
287		} // namespace chip