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

namespace chip {
namespace app {
namespace Clusters {
namespace AudioControl {
namespace Attributes {

namespace SoftMuted {
struct TypeInfo
{
    using Type             = bool;
    using DecodableType    = bool;
    using DecodableArgType = bool;

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

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

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

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

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

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

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

    static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::DefaultStepSize::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace DefaultStepSize
namespace SetVolumeUnmutePolicy {
struct TypeInfo
{
    using Type             = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
    using DecodableType    = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
    using DecodableArgType = chip::app::Clusters::AudioControl::UnmutePolicyEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::SetVolumeUnmutePolicy::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace SetVolumeUnmutePolicy
namespace IncreaseVolumeUnmutePolicy {
struct TypeInfo
{
    using Type             = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
    using DecodableType    = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
    using DecodableArgType = chip::app::Clusters::AudioControl::UnmutePolicyEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::IncreaseVolumeUnmutePolicy::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace IncreaseVolumeUnmutePolicy
namespace IncreaseVolumeUnmuteVolume {
struct TypeInfo
{
    using Type             = chip::app::Clusters::AudioControl::UnmuteVolumeEnum;
    using DecodableType    = chip::app::Clusters::AudioControl::UnmuteVolumeEnum;
    using DecodableArgType = chip::app::Clusters::AudioControl::UnmuteVolumeEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::IncreaseVolumeUnmuteVolume::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace IncreaseVolumeUnmuteVolume
namespace DecreaseVolumeUnmutePolicy {
struct TypeInfo
{
    using Type             = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
    using DecodableType    = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
    using DecodableArgType = chip::app::Clusters::AudioControl::UnmutePolicyEnum;

    static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::DecreaseVolumeUnmutePolicy::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace DecreaseVolumeUnmutePolicy
namespace StartUpMuted {
struct TypeInfo
{
    using Type             = chip::app::DataModel::Nullable<bool>;
    using DecodableType    = chip::app::DataModel::Nullable<bool>;
    using DecodableArgType = const chip::app::DataModel::Nullable<bool> &;

    static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
    static constexpr AttributeId GetAttributeId() { return Attributes::StartUpMuted::Id; }
    static constexpr bool MustUseTimedWrite() { return false; }
};
} // namespace StartUpMuted
namespace StartUpVolume {
struct TypeInfo
{
    using Type             = chip::app::DataModel::Nullable<uint16_t>;
    using DecodableType    = chip::app::DataModel::Nullable<uint16_t>;
    using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;

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

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

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

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

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

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

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

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

        Attributes::SoftMuted::TypeInfo::DecodableType softMuted                 = static_cast<bool>(0);
        Attributes::PhysicallyMuted::TypeInfo::DecodableType physicallyMuted     = static_cast<bool>(0);
        Attributes::Volume::TypeInfo::DecodableType volume                       = static_cast<uint16_t>(0);
        Attributes::MinDeviceVolume::TypeInfo::DecodableType minDeviceVolume     = static_cast<uint16_t>(0);
        Attributes::MaxDeviceVolume::TypeInfo::DecodableType maxDeviceVolume     = static_cast<uint16_t>(0);
        Attributes::MaxDeviceVolumeDB::TypeInfo::DecodableType maxDeviceVolumeDB = static_cast<uint16_t>(0);
        Attributes::MaxUserVolume::TypeInfo::DecodableType maxUserVolume         = static_cast<uint16_t>(0);
        Attributes::DefaultStepSize::TypeInfo::DecodableType defaultStepSize     = static_cast<uint16_t>(0);
        Attributes::SetVolumeUnmutePolicy::TypeInfo::DecodableType setVolumeUnmutePolicy =
            static_cast<chip::app::Clusters::AudioControl::UnmutePolicyEnum>(0);
        Attributes::IncreaseVolumeUnmutePolicy::TypeInfo::DecodableType increaseVolumeUnmutePolicy =
            static_cast<chip::app::Clusters::AudioControl::UnmutePolicyEnum>(0);
        Attributes::IncreaseVolumeUnmuteVolume::TypeInfo::DecodableType increaseVolumeUnmuteVolume =
            static_cast<chip::app::Clusters::AudioControl::UnmuteVolumeEnum>(0);
        Attributes::DecreaseVolumeUnmutePolicy::TypeInfo::DecodableType decreaseVolumeUnmutePolicy =
            static_cast<chip::app::Clusters::AudioControl::UnmutePolicyEnum>(0);
        Attributes::StartUpMuted::TypeInfo::DecodableType startUpMuted;
        Attributes::StartUpVolume::TypeInfo::DecodableType startUpVolume;
        Attributes::Bass::TypeInfo::DecodableType bass                   = static_cast<int16_t>(0);
        Attributes::Mid::TypeInfo::DecodableType mid                     = static_cast<int16_t>(0);
        Attributes::Treble::TypeInfo::DecodableType treble               = static_cast<int16_t>(0);
        Attributes::MinCorrection::TypeInfo::DecodableType minCorrection = static_cast<int16_t>(0);
        Attributes::MaxCorrection::TypeInfo::DecodableType maxCorrection = static_cast<int16_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 AudioControl
} // 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/AudioControl/AttributeIds.h>
36		#include <clusters/AudioControl/ClusterId.h>
37		#include <clusters/AudioControl/Enums.h>
38		#include <clusters/AudioControl/Structs.h>
39
40		namespace chip {
41		namespace app {
42		namespace Clusters {
43		namespace AudioControl {
44		namespace Attributes {
45
46		namespace SoftMuted {
47		struct TypeInfo
48		{
49		using Type = bool;
50		using DecodableType = bool;
51		using DecodableArgType = bool;
52
53	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
54	0	static constexpr AttributeId GetAttributeId() { return Attributes::SoftMuted::Id; }
55	0	static constexpr bool MustUseTimedWrite() { return false; }
56		};
57		} // namespace SoftMuted
58		namespace PhysicallyMuted {
59		struct TypeInfo
60		{
61		using Type = bool;
62		using DecodableType = bool;
63		using DecodableArgType = bool;
64
65	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
66	0	static constexpr AttributeId GetAttributeId() { return Attributes::PhysicallyMuted::Id; }
67	0	static constexpr bool MustUseTimedWrite() { return false; }
68		};
69		} // namespace PhysicallyMuted
70		namespace Volume {
71		struct TypeInfo
72		{
73		using Type = uint16_t;
74		using DecodableType = uint16_t;
75		using DecodableArgType = uint16_t;
76
77	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
78	0	static constexpr AttributeId GetAttributeId() { return Attributes::Volume::Id; }
79	0	static constexpr bool MustUseTimedWrite() { return false; }
80		};
81		} // namespace Volume
82		namespace MinDeviceVolume {
83		struct TypeInfo
84		{
85		using Type = uint16_t;
86		using DecodableType = uint16_t;
87		using DecodableArgType = uint16_t;
88
89	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
90	0	static constexpr AttributeId GetAttributeId() { return Attributes::MinDeviceVolume::Id; }
91	0	static constexpr bool MustUseTimedWrite() { return false; }
92		};
93		} // namespace MinDeviceVolume
94		namespace MaxDeviceVolume {
95		struct TypeInfo
96		{
97		using Type = uint16_t;
98		using DecodableType = uint16_t;
99		using DecodableArgType = uint16_t;
100
101	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
102	0	static constexpr AttributeId GetAttributeId() { return Attributes::MaxDeviceVolume::Id; }
103	0	static constexpr bool MustUseTimedWrite() { return false; }
104		};
105		} // namespace MaxDeviceVolume
106		namespace MaxDeviceVolumeDB {
107		struct TypeInfo
108		{
109		using Type = uint16_t;
110		using DecodableType = uint16_t;
111		using DecodableArgType = uint16_t;
112
113	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
114	0	static constexpr AttributeId GetAttributeId() { return Attributes::MaxDeviceVolumeDB::Id; }
115	0	static constexpr bool MustUseTimedWrite() { return false; }
116		};
117		} // namespace MaxDeviceVolumeDB
118		namespace MaxUserVolume {
119		struct TypeInfo
120		{
121		using Type = uint16_t;
122		using DecodableType = uint16_t;
123		using DecodableArgType = uint16_t;
124
125	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
126	0	static constexpr AttributeId GetAttributeId() { return Attributes::MaxUserVolume::Id; }
127	0	static constexpr bool MustUseTimedWrite() { return false; }
128		};
129		} // namespace MaxUserVolume
130		namespace DefaultStepSize {
131		struct TypeInfo
132		{
133		using Type = uint16_t;
134		using DecodableType = uint16_t;
135		using DecodableArgType = uint16_t;
136
137	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
138	0	static constexpr AttributeId GetAttributeId() { return Attributes::DefaultStepSize::Id; }
139	0	static constexpr bool MustUseTimedWrite() { return false; }
140		};
141		} // namespace DefaultStepSize
142		namespace SetVolumeUnmutePolicy {
143		struct TypeInfo
144		{
145		using Type = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
146		using DecodableType = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
147		using DecodableArgType = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
148
149	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
150	0	static constexpr AttributeId GetAttributeId() { return Attributes::SetVolumeUnmutePolicy::Id; }
151	0	static constexpr bool MustUseTimedWrite() { return false; }
152		};
153		} // namespace SetVolumeUnmutePolicy
154		namespace IncreaseVolumeUnmutePolicy {
155		struct TypeInfo
156		{
157		using Type = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
158		using DecodableType = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
159		using DecodableArgType = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
160
161	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
162	0	static constexpr AttributeId GetAttributeId() { return Attributes::IncreaseVolumeUnmutePolicy::Id; }
163	0	static constexpr bool MustUseTimedWrite() { return false; }
164		};
165		} // namespace IncreaseVolumeUnmutePolicy
166		namespace IncreaseVolumeUnmuteVolume {
167		struct TypeInfo
168		{
169		using Type = chip::app::Clusters::AudioControl::UnmuteVolumeEnum;
170		using DecodableType = chip::app::Clusters::AudioControl::UnmuteVolumeEnum;
171		using DecodableArgType = chip::app::Clusters::AudioControl::UnmuteVolumeEnum;
172
173	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
174	0	static constexpr AttributeId GetAttributeId() { return Attributes::IncreaseVolumeUnmuteVolume::Id; }
175	0	static constexpr bool MustUseTimedWrite() { return false; }
176		};
177		} // namespace IncreaseVolumeUnmuteVolume
178		namespace DecreaseVolumeUnmutePolicy {
179		struct TypeInfo
180		{
181		using Type = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
182		using DecodableType = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
183		using DecodableArgType = chip::app::Clusters::AudioControl::UnmutePolicyEnum;
184
185	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
186	0	static constexpr AttributeId GetAttributeId() { return Attributes::DecreaseVolumeUnmutePolicy::Id; }
187	0	static constexpr bool MustUseTimedWrite() { return false; }
188		};
189		} // namespace DecreaseVolumeUnmutePolicy
190		namespace StartUpMuted {
191		struct TypeInfo
192		{
193		using Type = chip::app::DataModel::Nullable<bool>;
194		using DecodableType = chip::app::DataModel::Nullable<bool>;
195		using DecodableArgType = const chip::app::DataModel::Nullable<bool> &;
196
197	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
198	0	static constexpr AttributeId GetAttributeId() { return Attributes::StartUpMuted::Id; }
199	0	static constexpr bool MustUseTimedWrite() { return false; }
200		};
201		} // namespace StartUpMuted
202		namespace StartUpVolume {
203		struct TypeInfo
204		{
205		using Type = chip::app::DataModel::Nullable<uint16_t>;
206		using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
207		using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &;
208
209	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
210	0	static constexpr AttributeId GetAttributeId() { return Attributes::StartUpVolume::Id; }
211	0	static constexpr bool MustUseTimedWrite() { return false; }
212		};
213		} // namespace StartUpVolume
214		namespace Bass {
215		struct TypeInfo
216		{
217		using Type = int16_t;
218		using DecodableType = int16_t;
219		using DecodableArgType = int16_t;
220
221	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
222	0	static constexpr AttributeId GetAttributeId() { return Attributes::Bass::Id; }
223	0	static constexpr bool MustUseTimedWrite() { return false; }
224		};
225		} // namespace Bass
226		namespace Mid {
227		struct TypeInfo
228		{
229		using Type = int16_t;
230		using DecodableType = int16_t;
231		using DecodableArgType = int16_t;
232
233	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
234	0	static constexpr AttributeId GetAttributeId() { return Attributes::Mid::Id; }
235	0	static constexpr bool MustUseTimedWrite() { return false; }
236		};
237		} // namespace Mid
238		namespace Treble {
239		struct TypeInfo
240		{
241		using Type = int16_t;
242		using DecodableType = int16_t;
243		using DecodableArgType = int16_t;
244
245	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
246	0	static constexpr AttributeId GetAttributeId() { return Attributes::Treble::Id; }
247	0	static constexpr bool MustUseTimedWrite() { return false; }
248		};
249		} // namespace Treble
250		namespace MinCorrection {
251		struct TypeInfo
252		{
253		using Type = int16_t;
254		using DecodableType = int16_t;
255		using DecodableArgType = int16_t;
256
257	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
258	0	static constexpr AttributeId GetAttributeId() { return Attributes::MinCorrection::Id; }
259	0	static constexpr bool MustUseTimedWrite() { return false; }
260		};
261		} // namespace MinCorrection
262		namespace MaxCorrection {
263		struct TypeInfo
264		{
265		using Type = int16_t;
266		using DecodableType = int16_t;
267		using DecodableArgType = int16_t;
268
269	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
270	0	static constexpr AttributeId GetAttributeId() { return Attributes::MaxCorrection::Id; }
271	0	static constexpr bool MustUseTimedWrite() { return false; }
272		};
273		} // namespace MaxCorrection
274		namespace GeneratedCommandList {
275		struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo
276		{
277	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
278		};
279		} // namespace GeneratedCommandList
280		namespace AcceptedCommandList {
281		struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo
282		{
283	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
284		};
285		} // namespace AcceptedCommandList
286		namespace AttributeList {
287		struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo
288		{
289	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
290		};
291		} // namespace AttributeList
292		namespace FeatureMap {
293		struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo
294		{
295	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
296		};
297		} // namespace FeatureMap
298		namespace ClusterRevision {
299		struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo
300		{
301	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
302		};
303		} // namespace ClusterRevision
304
305		struct TypeInfo
306		{
307		struct DecodableType
308		{
309	0	static constexpr ClusterId GetClusterId() { return Clusters::AudioControl::Id; }
310
311		CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path);
312
313		Attributes::SoftMuted::TypeInfo::DecodableType softMuted = static_cast<bool>(0);
314		Attributes::PhysicallyMuted::TypeInfo::DecodableType physicallyMuted = static_cast<bool>(0);
315		Attributes::Volume::TypeInfo::DecodableType volume = static_cast<uint16_t>(0);
316		Attributes::MinDeviceVolume::TypeInfo::DecodableType minDeviceVolume = static_cast<uint16_t>(0);
317		Attributes::MaxDeviceVolume::TypeInfo::DecodableType maxDeviceVolume = static_cast<uint16_t>(0);
318		Attributes::MaxDeviceVolumeDB::TypeInfo::DecodableType maxDeviceVolumeDB = static_cast<uint16_t>(0);
319		Attributes::MaxUserVolume::TypeInfo::DecodableType maxUserVolume = static_cast<uint16_t>(0);
320		Attributes::DefaultStepSize::TypeInfo::DecodableType defaultStepSize = static_cast<uint16_t>(0);
321		Attributes::SetVolumeUnmutePolicy::TypeInfo::DecodableType setVolumeUnmutePolicy =
322		static_cast<chip::app::Clusters::AudioControl::UnmutePolicyEnum>(0);
323		Attributes::IncreaseVolumeUnmutePolicy::TypeInfo::DecodableType increaseVolumeUnmutePolicy =
324		static_cast<chip::app::Clusters::AudioControl::UnmutePolicyEnum>(0);
325		Attributes::IncreaseVolumeUnmuteVolume::TypeInfo::DecodableType increaseVolumeUnmuteVolume =
326		static_cast<chip::app::Clusters::AudioControl::UnmuteVolumeEnum>(0);
327		Attributes::DecreaseVolumeUnmutePolicy::TypeInfo::DecodableType decreaseVolumeUnmutePolicy =
328		static_cast<chip::app::Clusters::AudioControl::UnmutePolicyEnum>(0);
329		Attributes::StartUpMuted::TypeInfo::DecodableType startUpMuted;
330		Attributes::StartUpVolume::TypeInfo::DecodableType startUpVolume;
331		Attributes::Bass::TypeInfo::DecodableType bass = static_cast<int16_t>(0);
332		Attributes::Mid::TypeInfo::DecodableType mid = static_cast<int16_t>(0);
333		Attributes::Treble::TypeInfo::DecodableType treble = static_cast<int16_t>(0);
334		Attributes::MinCorrection::TypeInfo::DecodableType minCorrection = static_cast<int16_t>(0);
335		Attributes::MaxCorrection::TypeInfo::DecodableType maxCorrection = static_cast<int16_t>(0);
336		Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList;
337		Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList;
338		Attributes::AttributeList::TypeInfo::DecodableType attributeList;
339		Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0);
340		Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0);
341		};
342		};
343		} // namespace Attributes
344		} // namespace AudioControl
345		} // namespace Clusters
346		} // namespace app
347		} // namespace chip