/src/connectedhomeip/zzz_generated/app-common/clusters/AvAnalysis/Commands.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-Commands.h.zapt

#pragma once

#include <app/data-model/DecodableList.h>
#include <app/data-model/Encode.h>
#include <app/data-model/List.h>
#include <app/data-model/NullObject.h>
#include <app/data-model/Nullable.h>
#include <lib/core/DataModelTypes.h>
#include <lib/core/Optional.h>
#include <lib/core/TLV.h>
#include <lib/support/BitMask.h>

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

#include <clusters/AvAnalysis/ClusterId.h>
#include <clusters/AvAnalysis/CommandIds.h>
#include <clusters/AvAnalysis/Enums.h>
#include <clusters/AvAnalysis/Structs.h>

#include <cstdint>

namespace chip {
namespace app {
namespace Clusters {
namespace AvAnalysis {
namespace Commands {
// Forward-declarations so we can reference these later.

namespace EnableContextTriggers {
struct Type;
struct DecodableType;
} // namespace EnableContextTriggers

namespace DisableContextTriggers {
struct Type;
struct DecodableType;
} // namespace DisableContextTriggers

namespace EstablishAnalysisStream {
struct Type;
struct DecodableType;
} // namespace EstablishAnalysisStream

namespace EstablishAnalysisStreamResponse {
struct Type;
struct DecodableType;
} // namespace EstablishAnalysisStreamResponse

namespace ActivateAnalysisStream {
struct Type;
struct DecodableType;
} // namespace ActivateAnalysisStream

namespace DeactivateAnalysisStream {
struct Type;
struct DecodableType;
} // namespace DeactivateAnalysisStream

namespace RemoveAnalysisStream {
struct Type;
struct DecodableType;
} // namespace RemoveAnalysisStream

} // namespace Commands

namespace Commands {
namespace EnableContextTriggers {
enum class Fields : uint8_t
{
    kContextTriggers = 0,
};

struct Type
{
public:
    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
    static constexpr CommandId GetCommandId() { return Commands::EnableContextTriggers::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }

    DataModel::Nullable<DataModel::List<const Structs::ContextTriggerStruct::Type>> contextTriggers;

    CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;

    using ResponseType = DataModel::NullObjectType;

    static constexpr bool MustUseTimedInvoke() { return false; }
};

struct DecodableType
{
public:
    static constexpr CommandId GetCommandId() { return Commands::EnableContextTriggers::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
    static constexpr bool kIsFabricScoped = false;

    DataModel::Nullable<DataModel::DecodableList<Structs::ContextTriggerStruct::DecodableType>> contextTriggers;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace EnableContextTriggers
namespace DisableContextTriggers {
enum class Fields : uint8_t
{
    kContextTriggers = 0,
};

struct Type
{
public:
    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
    static constexpr CommandId GetCommandId() { return Commands::DisableContextTriggers::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }

    DataModel::Nullable<DataModel::List<const Structs::ContextTriggerStruct::Type>> contextTriggers;

    CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;

    using ResponseType = DataModel::NullObjectType;

    static constexpr bool MustUseTimedInvoke() { return false; }
};

struct DecodableType
{
public:
    static constexpr CommandId GetCommandId() { return Commands::DisableContextTriggers::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
    static constexpr bool kIsFabricScoped = false;

    DataModel::Nullable<DataModel::DecodableList<Structs::ContextTriggerStruct::DecodableType>> contextTriggers;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace DisableContextTriggers
namespace EstablishAnalysisStream {
enum class Fields : uint8_t
{
    kNodeID = 0,
};

struct Type
{
public:
    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
    static constexpr CommandId GetCommandId() { return Commands::EstablishAnalysisStream::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }

    chip::NodeId nodeID = static_cast<chip::NodeId>(0);

    CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;

    using ResponseType = Clusters::AvAnalysis::Commands::EstablishAnalysisStreamResponse::DecodableType;

    static constexpr bool MustUseTimedInvoke() { return false; }
};

struct DecodableType
{
public:
    static constexpr CommandId GetCommandId() { return Commands::EstablishAnalysisStream::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
    static constexpr bool kIsFabricScoped = false;

    chip::NodeId nodeID = static_cast<chip::NodeId>(0);

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace EstablishAnalysisStream
namespace EstablishAnalysisStreamResponse {
enum class Fields : uint8_t
{
    kAnalysisStreamID = 0,
};

struct Type
{
public:
    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
    static constexpr CommandId GetCommandId() { return Commands::EstablishAnalysisStreamResponse::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }

    uint16_t analysisStreamID = static_cast<uint16_t>(0);

    CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter & aWriter, TLV::Tag aTag) const;

    using ResponseType = DataModel::NullObjectType;

    static constexpr bool MustUseTimedInvoke() { return false; }
};

struct DecodableType
{
public:
    static constexpr CommandId GetCommandId() { return Commands::EstablishAnalysisStreamResponse::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }

    uint16_t analysisStreamID = static_cast<uint16_t>(0);

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace EstablishAnalysisStreamResponse
namespace ActivateAnalysisStream {
enum class Fields : uint8_t
{
    kAnalysisStreamID = 0,
    kWebRTCEndpointID = 1,
    kPushAVEndpointID = 2,
};

struct Type
{
public:
    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
    static constexpr CommandId GetCommandId() { return Commands::ActivateAnalysisStream::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }

    uint16_t analysisStreamID = static_cast<uint16_t>(0);
    Optional<chip::EndpointId> webRTCEndpointID;
    Optional<chip::EndpointId> pushAVEndpointID;

    CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;

    using ResponseType = DataModel::NullObjectType;

    static constexpr bool MustUseTimedInvoke() { return false; }
};

struct DecodableType
{
public:
    static constexpr CommandId GetCommandId() { return Commands::ActivateAnalysisStream::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t analysisStreamID = static_cast<uint16_t>(0);
    Optional<chip::EndpointId> webRTCEndpointID;
    Optional<chip::EndpointId> pushAVEndpointID;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace ActivateAnalysisStream
namespace DeactivateAnalysisStream {
enum class Fields : uint8_t
{
    kAnalysisStreamID = 0,
};

struct Type
{
public:
    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
    static constexpr CommandId GetCommandId() { return Commands::DeactivateAnalysisStream::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }

    uint16_t analysisStreamID = static_cast<uint16_t>(0);

    CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;

    using ResponseType = DataModel::NullObjectType;

    static constexpr bool MustUseTimedInvoke() { return false; }
};

struct DecodableType
{
public:
    static constexpr CommandId GetCommandId() { return Commands::DeactivateAnalysisStream::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t analysisStreamID = static_cast<uint16_t>(0);

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace DeactivateAnalysisStream
namespace RemoveAnalysisStream {
enum class Fields : uint8_t
{
    kAnalysisStreamID = 0,
};

struct Type
{
public:
    // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
    static constexpr CommandId GetCommandId() { return Commands::RemoveAnalysisStream::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }

    uint16_t analysisStreamID = static_cast<uint16_t>(0);

    CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;

    using ResponseType = DataModel::NullObjectType;

    static constexpr bool MustUseTimedInvoke() { return false; }
};

struct DecodableType
{
public:
    static constexpr CommandId GetCommandId() { return Commands::RemoveAnalysisStream::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t analysisStreamID = static_cast<uint16_t>(0);

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace RemoveAnalysisStream
} // namespace Commands
} // namespace AvAnalysis
} // namespace Clusters
} // namespace app
} // namespace chip

Coverage Report

Created: 2026-09-24 06:58

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-Commands.h.zapt
20
21		#pragma once
22
23		#include <app/data-model/DecodableList.h>
24		#include <app/data-model/Encode.h>
25		#include <app/data-model/List.h>
26		#include <app/data-model/NullObject.h>
27		#include <app/data-model/Nullable.h>
28		#include <lib/core/DataModelTypes.h>
29		#include <lib/core/Optional.h>
30		#include <lib/core/TLV.h>
31		#include <lib/support/BitMask.h>
32
33		#include <clusters/shared/Enums.h>
34		#include <clusters/shared/Structs.h>
35
36		#include <clusters/AvAnalysis/ClusterId.h>
37		#include <clusters/AvAnalysis/CommandIds.h>
38		#include <clusters/AvAnalysis/Enums.h>
39		#include <clusters/AvAnalysis/Structs.h>
40
41		#include <cstdint>
42
43		namespace chip {
44		namespace app {
45		namespace Clusters {
46		namespace AvAnalysis {
47		namespace Commands {
48		// Forward-declarations so we can reference these later.
49
50		namespace EnableContextTriggers {
51		struct Type;
52		struct DecodableType;
53		} // namespace EnableContextTriggers
54
55		namespace DisableContextTriggers {
56		struct Type;
57		struct DecodableType;
58		} // namespace DisableContextTriggers
59
60		namespace EstablishAnalysisStream {
61		struct Type;
62		struct DecodableType;
63		} // namespace EstablishAnalysisStream
64
65		namespace EstablishAnalysisStreamResponse {
66		struct Type;
67		struct DecodableType;
68		} // namespace EstablishAnalysisStreamResponse
69
70		namespace ActivateAnalysisStream {
71		struct Type;
72		struct DecodableType;
73		} // namespace ActivateAnalysisStream
74
75		namespace DeactivateAnalysisStream {
76		struct Type;
77		struct DecodableType;
78		} // namespace DeactivateAnalysisStream
79
80		namespace RemoveAnalysisStream {
81		struct Type;
82		struct DecodableType;
83		} // namespace RemoveAnalysisStream
84
85		} // namespace Commands
86
87		namespace Commands {
88		namespace EnableContextTriggers {
89		enum class Fields : uint8_t
90		{
91		kContextTriggers = 0,
92		};
93
94		struct Type
95		{
96		public:
97		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
98	0	static constexpr CommandId GetCommandId() { return Commands::EnableContextTriggers::Id; }
99	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
100
101		DataModel::Nullable<DataModel::List<const Structs::ContextTriggerStruct::Type>> contextTriggers;
102
103		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
104
105		using ResponseType = DataModel::NullObjectType;
106
107	0	static constexpr bool MustUseTimedInvoke() { return false; }
108		};
109
110		struct DecodableType
111		{
112		public:
113	0	static constexpr CommandId GetCommandId() { return Commands::EnableContextTriggers::Id; }
114	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
115		static constexpr bool kIsFabricScoped = false;
116
117		DataModel::Nullable<DataModel::DecodableList<Structs::ContextTriggerStruct::DecodableType>> contextTriggers;
118
119		CHIP_ERROR Decode(TLV::TLVReader & reader);
120		};
121		}; // namespace EnableContextTriggers
122		namespace DisableContextTriggers {
123		enum class Fields : uint8_t
124		{
125		kContextTriggers = 0,
126		};
127
128		struct Type
129		{
130		public:
131		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
132	0	static constexpr CommandId GetCommandId() { return Commands::DisableContextTriggers::Id; }
133	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
134
135		DataModel::Nullable<DataModel::List<const Structs::ContextTriggerStruct::Type>> contextTriggers;
136
137		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
138
139		using ResponseType = DataModel::NullObjectType;
140
141	0	static constexpr bool MustUseTimedInvoke() { return false; }
142		};
143
144		struct DecodableType
145		{
146		public:
147	0	static constexpr CommandId GetCommandId() { return Commands::DisableContextTriggers::Id; }
148	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
149		static constexpr bool kIsFabricScoped = false;
150
151		DataModel::Nullable<DataModel::DecodableList<Structs::ContextTriggerStruct::DecodableType>> contextTriggers;
152
153		CHIP_ERROR Decode(TLV::TLVReader & reader);
154		};
155		}; // namespace DisableContextTriggers
156		namespace EstablishAnalysisStream {
157		enum class Fields : uint8_t
158		{
159		kNodeID = 0,
160		};
161
162		struct Type
163		{
164		public:
165		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
166	0	static constexpr CommandId GetCommandId() { return Commands::EstablishAnalysisStream::Id; }
167	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
168
169		chip::NodeId nodeID = static_cast<chip::NodeId>(0);
170
171		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
172
173		using ResponseType = Clusters::AvAnalysis::Commands::EstablishAnalysisStreamResponse::DecodableType;
174
175	0	static constexpr bool MustUseTimedInvoke() { return false; }
176		};
177
178		struct DecodableType
179		{
180		public:
181	0	static constexpr CommandId GetCommandId() { return Commands::EstablishAnalysisStream::Id; }
182	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
183		static constexpr bool kIsFabricScoped = false;
184
185		chip::NodeId nodeID = static_cast<chip::NodeId>(0);
186
187		CHIP_ERROR Decode(TLV::TLVReader & reader);
188		};
189		}; // namespace EstablishAnalysisStream
190		namespace EstablishAnalysisStreamResponse {
191		enum class Fields : uint8_t
192		{
193		kAnalysisStreamID = 0,
194		};
195
196		struct Type
197		{
198		public:
199		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
200	0	static constexpr CommandId GetCommandId() { return Commands::EstablishAnalysisStreamResponse::Id; }
201	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
202
203		uint16_t analysisStreamID = static_cast<uint16_t>(0);
204
205		CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter & aWriter, TLV::Tag aTag) const;
206
207		using ResponseType = DataModel::NullObjectType;
208
209	0	static constexpr bool MustUseTimedInvoke() { return false; }
210		};
211
212		struct DecodableType
213		{
214		public:
215	0	static constexpr CommandId GetCommandId() { return Commands::EstablishAnalysisStreamResponse::Id; }
216	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
217
218		uint16_t analysisStreamID = static_cast<uint16_t>(0);
219
220		CHIP_ERROR Decode(TLV::TLVReader & reader);
221		};
222		}; // namespace EstablishAnalysisStreamResponse
223		namespace ActivateAnalysisStream {
224		enum class Fields : uint8_t
225		{
226		kAnalysisStreamID = 0,
227		kWebRTCEndpointID = 1,
228		kPushAVEndpointID = 2,
229		};
230
231		struct Type
232		{
233		public:
234		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
235	0	static constexpr CommandId GetCommandId() { return Commands::ActivateAnalysisStream::Id; }
236	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
237
238		uint16_t analysisStreamID = static_cast<uint16_t>(0);
239		Optional<chip::EndpointId> webRTCEndpointID;
240		Optional<chip::EndpointId> pushAVEndpointID;
241
242		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
243
244		using ResponseType = DataModel::NullObjectType;
245
246	0	static constexpr bool MustUseTimedInvoke() { return false; }
247		};
248
249		struct DecodableType
250		{
251		public:
252	0	static constexpr CommandId GetCommandId() { return Commands::ActivateAnalysisStream::Id; }
253	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
254		static constexpr bool kIsFabricScoped = false;
255
256		uint16_t analysisStreamID = static_cast<uint16_t>(0);
257		Optional<chip::EndpointId> webRTCEndpointID;
258		Optional<chip::EndpointId> pushAVEndpointID;
259
260		CHIP_ERROR Decode(TLV::TLVReader & reader);
261		};
262		}; // namespace ActivateAnalysisStream
263		namespace DeactivateAnalysisStream {
264		enum class Fields : uint8_t
265		{
266		kAnalysisStreamID = 0,
267		};
268
269		struct Type
270		{
271		public:
272		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
273	0	static constexpr CommandId GetCommandId() { return Commands::DeactivateAnalysisStream::Id; }
274	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
275
276		uint16_t analysisStreamID = static_cast<uint16_t>(0);
277
278		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
279
280		using ResponseType = DataModel::NullObjectType;
281
282	0	static constexpr bool MustUseTimedInvoke() { return false; }
283		};
284
285		struct DecodableType
286		{
287		public:
288	0	static constexpr CommandId GetCommandId() { return Commands::DeactivateAnalysisStream::Id; }
289	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
290		static constexpr bool kIsFabricScoped = false;
291
292		uint16_t analysisStreamID = static_cast<uint16_t>(0);
293
294		CHIP_ERROR Decode(TLV::TLVReader & reader);
295		};
296		}; // namespace DeactivateAnalysisStream
297		namespace RemoveAnalysisStream {
298		enum class Fields : uint8_t
299		{
300		kAnalysisStreamID = 0,
301		};
302
303		struct Type
304		{
305		public:
306		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
307	0	static constexpr CommandId GetCommandId() { return Commands::RemoveAnalysisStream::Id; }
308	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
309
310		uint16_t analysisStreamID = static_cast<uint16_t>(0);
311
312		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
313
314		using ResponseType = DataModel::NullObjectType;
315
316	0	static constexpr bool MustUseTimedInvoke() { return false; }
317		};
318
319		struct DecodableType
320		{
321		public:
322	0	static constexpr CommandId GetCommandId() { return Commands::RemoveAnalysisStream::Id; }
323	0	static constexpr ClusterId GetClusterId() { return Clusters::AvAnalysis::Id; }
324		static constexpr bool kIsFabricScoped = false;
325
326		uint16_t analysisStreamID = static_cast<uint16_t>(0);
327
328		CHIP_ERROR Decode(TLV::TLVReader & reader);
329		};
330		}; // namespace RemoveAnalysisStream
331		} // namespace Commands
332		} // namespace AvAnalysis
333		} // namespace Clusters
334		} // namespace app
335		} // namespace chip