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

#include <cstdint>

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace Commands

namespace Commands {
namespace InstantAction {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    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::InstantAction::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace InstantAction
namespace InstantActionWithTransition {
enum class Fields : uint8_t
{
    kActionID       = 0,
    kInvokeID       = 1,
    kTransitionTime = 2,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint16_t transitionTime = 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::InstantActionWithTransition::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint16_t transitionTime = static_cast<uint16_t>(0);

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace InstantActionWithTransition
namespace StartAction {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    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::StartAction::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace StartAction
namespace StartActionWithDuration {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
    kDuration = 2,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint32_t duration = static_cast<uint32_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::StartActionWithDuration::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint32_t duration = static_cast<uint32_t>(0);

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace StartActionWithDuration
namespace StopAction {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    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::StopAction::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace StopAction
namespace PauseAction {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    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::PauseAction::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace PauseAction
namespace PauseActionWithDuration {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
    kDuration = 2,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint32_t duration = static_cast<uint32_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::PauseActionWithDuration::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint32_t duration = static_cast<uint32_t>(0);

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace PauseActionWithDuration
namespace ResumeAction {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    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::ResumeAction::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace ResumeAction
namespace EnableAction {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    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::EnableAction::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace EnableAction
namespace EnableActionWithDuration {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
    kDuration = 2,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint32_t duration = static_cast<uint32_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::EnableActionWithDuration::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint32_t duration = static_cast<uint32_t>(0);

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace EnableActionWithDuration
namespace DisableAction {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    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::DisableAction::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace DisableAction
namespace DisableActionWithDuration {
enum class Fields : uint8_t
{
    kActionID = 0,
    kInvokeID = 1,
    kDuration = 2,
};

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

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint32_t duration = static_cast<uint32_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::DisableActionWithDuration::Id; }
    static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
    static constexpr bool kIsFabricScoped = false;

    uint16_t actionID = static_cast<uint16_t>(0);
    Optional<uint32_t> invokeID;
    uint32_t duration = static_cast<uint32_t>(0);

    CHIP_ERROR Decode(TLV::TLVReader & reader);
};
}; // namespace DisableActionWithDuration
} // namespace Commands
} // namespace Actions
} // 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-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/Actions/ClusterId.h>
37		#include <clusters/Actions/CommandIds.h>
38		#include <clusters/Actions/Enums.h>
39		#include <clusters/Actions/Structs.h>
40
41		#include <cstdint>
42
43		namespace chip {
44		namespace app {
45		namespace Clusters {
46		namespace Actions {
47		namespace Commands {
48		// Forward-declarations so we can reference these later.
49
50		namespace InstantAction {
51		struct Type;
52		struct DecodableType;
53		} // namespace InstantAction
54
55		namespace InstantActionWithTransition {
56		struct Type;
57		struct DecodableType;
58		} // namespace InstantActionWithTransition
59
60		namespace StartAction {
61		struct Type;
62		struct DecodableType;
63		} // namespace StartAction
64
65		namespace StartActionWithDuration {
66		struct Type;
67		struct DecodableType;
68		} // namespace StartActionWithDuration
69
70		namespace StopAction {
71		struct Type;
72		struct DecodableType;
73		} // namespace StopAction
74
75		namespace PauseAction {
76		struct Type;
77		struct DecodableType;
78		} // namespace PauseAction
79
80		namespace PauseActionWithDuration {
81		struct Type;
82		struct DecodableType;
83		} // namespace PauseActionWithDuration
84
85		namespace ResumeAction {
86		struct Type;
87		struct DecodableType;
88		} // namespace ResumeAction
89
90		namespace EnableAction {
91		struct Type;
92		struct DecodableType;
93		} // namespace EnableAction
94
95		namespace EnableActionWithDuration {
96		struct Type;
97		struct DecodableType;
98		} // namespace EnableActionWithDuration
99
100		namespace DisableAction {
101		struct Type;
102		struct DecodableType;
103		} // namespace DisableAction
104
105		namespace DisableActionWithDuration {
106		struct Type;
107		struct DecodableType;
108		} // namespace DisableActionWithDuration
109
110		} // namespace Commands
111
112		namespace Commands {
113		namespace InstantAction {
114		enum class Fields : uint8_t
115		{
116		kActionID = 0,
117		kInvokeID = 1,
118		};
119
120		struct Type
121		{
122		public:
123		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
124	0	static constexpr CommandId GetCommandId() { return Commands::InstantAction::Id; }
125	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
126
127		uint16_t actionID = static_cast<uint16_t>(0);
128		Optional<uint32_t> invokeID;
129
130		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
131
132		using ResponseType = DataModel::NullObjectType;
133
134	0	static constexpr bool MustUseTimedInvoke() { return false; }
135		};
136
137		struct DecodableType
138		{
139		public:
140	0	static constexpr CommandId GetCommandId() { return Commands::InstantAction::Id; }
141	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
142		static constexpr bool kIsFabricScoped = false;
143
144		uint16_t actionID = static_cast<uint16_t>(0);
145		Optional<uint32_t> invokeID;
146
147		CHIP_ERROR Decode(TLV::TLVReader & reader);
148		};
149		}; // namespace InstantAction
150		namespace InstantActionWithTransition {
151		enum class Fields : uint8_t
152		{
153		kActionID = 0,
154		kInvokeID = 1,
155		kTransitionTime = 2,
156		};
157
158		struct Type
159		{
160		public:
161		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
162	0	static constexpr CommandId GetCommandId() { return Commands::InstantActionWithTransition::Id; }
163	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
164
165		uint16_t actionID = static_cast<uint16_t>(0);
166		Optional<uint32_t> invokeID;
167		uint16_t transitionTime = static_cast<uint16_t>(0);
168
169		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
170
171		using ResponseType = DataModel::NullObjectType;
172
173	0	static constexpr bool MustUseTimedInvoke() { return false; }
174		};
175
176		struct DecodableType
177		{
178		public:
179	0	static constexpr CommandId GetCommandId() { return Commands::InstantActionWithTransition::Id; }
180	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
181		static constexpr bool kIsFabricScoped = false;
182
183		uint16_t actionID = static_cast<uint16_t>(0);
184		Optional<uint32_t> invokeID;
185		uint16_t transitionTime = static_cast<uint16_t>(0);
186
187		CHIP_ERROR Decode(TLV::TLVReader & reader);
188		};
189		}; // namespace InstantActionWithTransition
190		namespace StartAction {
191		enum class Fields : uint8_t
192		{
193		kActionID = 0,
194		kInvokeID = 1,
195		};
196
197		struct Type
198		{
199		public:
200		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
201	0	static constexpr CommandId GetCommandId() { return Commands::StartAction::Id; }
202	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
203
204		uint16_t actionID = static_cast<uint16_t>(0);
205		Optional<uint32_t> invokeID;
206
207		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
208
209		using ResponseType = DataModel::NullObjectType;
210
211	0	static constexpr bool MustUseTimedInvoke() { return false; }
212		};
213
214		struct DecodableType
215		{
216		public:
217	0	static constexpr CommandId GetCommandId() { return Commands::StartAction::Id; }
218	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
219		static constexpr bool kIsFabricScoped = false;
220
221		uint16_t actionID = static_cast<uint16_t>(0);
222		Optional<uint32_t> invokeID;
223
224		CHIP_ERROR Decode(TLV::TLVReader & reader);
225		};
226		}; // namespace StartAction
227		namespace StartActionWithDuration {
228		enum class Fields : uint8_t
229		{
230		kActionID = 0,
231		kInvokeID = 1,
232		kDuration = 2,
233		};
234
235		struct Type
236		{
237		public:
238		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
239	0	static constexpr CommandId GetCommandId() { return Commands::StartActionWithDuration::Id; }
240	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
241
242		uint16_t actionID = static_cast<uint16_t>(0);
243		Optional<uint32_t> invokeID;
244		uint32_t duration = static_cast<uint32_t>(0);
245
246		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
247
248		using ResponseType = DataModel::NullObjectType;
249
250	0	static constexpr bool MustUseTimedInvoke() { return false; }
251		};
252
253		struct DecodableType
254		{
255		public:
256	0	static constexpr CommandId GetCommandId() { return Commands::StartActionWithDuration::Id; }
257	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
258		static constexpr bool kIsFabricScoped = false;
259
260		uint16_t actionID = static_cast<uint16_t>(0);
261		Optional<uint32_t> invokeID;
262		uint32_t duration = static_cast<uint32_t>(0);
263
264		CHIP_ERROR Decode(TLV::TLVReader & reader);
265		};
266		}; // namespace StartActionWithDuration
267		namespace StopAction {
268		enum class Fields : uint8_t
269		{
270		kActionID = 0,
271		kInvokeID = 1,
272		};
273
274		struct Type
275		{
276		public:
277		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
278	0	static constexpr CommandId GetCommandId() { return Commands::StopAction::Id; }
279	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
280
281		uint16_t actionID = static_cast<uint16_t>(0);
282		Optional<uint32_t> invokeID;
283
284		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
285
286		using ResponseType = DataModel::NullObjectType;
287
288	0	static constexpr bool MustUseTimedInvoke() { return false; }
289		};
290
291		struct DecodableType
292		{
293		public:
294	0	static constexpr CommandId GetCommandId() { return Commands::StopAction::Id; }
295	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
296		static constexpr bool kIsFabricScoped = false;
297
298		uint16_t actionID = static_cast<uint16_t>(0);
299		Optional<uint32_t> invokeID;
300
301		CHIP_ERROR Decode(TLV::TLVReader & reader);
302		};
303		}; // namespace StopAction
304		namespace PauseAction {
305		enum class Fields : uint8_t
306		{
307		kActionID = 0,
308		kInvokeID = 1,
309		};
310
311		struct Type
312		{
313		public:
314		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
315	0	static constexpr CommandId GetCommandId() { return Commands::PauseAction::Id; }
316	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
317
318		uint16_t actionID = static_cast<uint16_t>(0);
319		Optional<uint32_t> invokeID;
320
321		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
322
323		using ResponseType = DataModel::NullObjectType;
324
325	0	static constexpr bool MustUseTimedInvoke() { return false; }
326		};
327
328		struct DecodableType
329		{
330		public:
331	0	static constexpr CommandId GetCommandId() { return Commands::PauseAction::Id; }
332	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
333		static constexpr bool kIsFabricScoped = false;
334
335		uint16_t actionID = static_cast<uint16_t>(0);
336		Optional<uint32_t> invokeID;
337
338		CHIP_ERROR Decode(TLV::TLVReader & reader);
339		};
340		}; // namespace PauseAction
341		namespace PauseActionWithDuration {
342		enum class Fields : uint8_t
343		{
344		kActionID = 0,
345		kInvokeID = 1,
346		kDuration = 2,
347		};
348
349		struct Type
350		{
351		public:
352		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
353	0	static constexpr CommandId GetCommandId() { return Commands::PauseActionWithDuration::Id; }
354	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
355
356		uint16_t actionID = static_cast<uint16_t>(0);
357		Optional<uint32_t> invokeID;
358		uint32_t duration = static_cast<uint32_t>(0);
359
360		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
361
362		using ResponseType = DataModel::NullObjectType;
363
364	0	static constexpr bool MustUseTimedInvoke() { return false; }
365		};
366
367		struct DecodableType
368		{
369		public:
370	0	static constexpr CommandId GetCommandId() { return Commands::PauseActionWithDuration::Id; }
371	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
372		static constexpr bool kIsFabricScoped = false;
373
374		uint16_t actionID = static_cast<uint16_t>(0);
375		Optional<uint32_t> invokeID;
376		uint32_t duration = static_cast<uint32_t>(0);
377
378		CHIP_ERROR Decode(TLV::TLVReader & reader);
379		};
380		}; // namespace PauseActionWithDuration
381		namespace ResumeAction {
382		enum class Fields : uint8_t
383		{
384		kActionID = 0,
385		kInvokeID = 1,
386		};
387
388		struct Type
389		{
390		public:
391		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
392	0	static constexpr CommandId GetCommandId() { return Commands::ResumeAction::Id; }
393	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
394
395		uint16_t actionID = static_cast<uint16_t>(0);
396		Optional<uint32_t> invokeID;
397
398		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
399
400		using ResponseType = DataModel::NullObjectType;
401
402	0	static constexpr bool MustUseTimedInvoke() { return false; }
403		};
404
405		struct DecodableType
406		{
407		public:
408	0	static constexpr CommandId GetCommandId() { return Commands::ResumeAction::Id; }
409	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
410		static constexpr bool kIsFabricScoped = false;
411
412		uint16_t actionID = static_cast<uint16_t>(0);
413		Optional<uint32_t> invokeID;
414
415		CHIP_ERROR Decode(TLV::TLVReader & reader);
416		};
417		}; // namespace ResumeAction
418		namespace EnableAction {
419		enum class Fields : uint8_t
420		{
421		kActionID = 0,
422		kInvokeID = 1,
423		};
424
425		struct Type
426		{
427		public:
428		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
429	0	static constexpr CommandId GetCommandId() { return Commands::EnableAction::Id; }
430	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
431
432		uint16_t actionID = static_cast<uint16_t>(0);
433		Optional<uint32_t> invokeID;
434
435		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
436
437		using ResponseType = DataModel::NullObjectType;
438
439	0	static constexpr bool MustUseTimedInvoke() { return false; }
440		};
441
442		struct DecodableType
443		{
444		public:
445	0	static constexpr CommandId GetCommandId() { return Commands::EnableAction::Id; }
446	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
447		static constexpr bool kIsFabricScoped = false;
448
449		uint16_t actionID = static_cast<uint16_t>(0);
450		Optional<uint32_t> invokeID;
451
452		CHIP_ERROR Decode(TLV::TLVReader & reader);
453		};
454		}; // namespace EnableAction
455		namespace EnableActionWithDuration {
456		enum class Fields : uint8_t
457		{
458		kActionID = 0,
459		kInvokeID = 1,
460		kDuration = 2,
461		};
462
463		struct Type
464		{
465		public:
466		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
467	0	static constexpr CommandId GetCommandId() { return Commands::EnableActionWithDuration::Id; }
468	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
469
470		uint16_t actionID = static_cast<uint16_t>(0);
471		Optional<uint32_t> invokeID;
472		uint32_t duration = static_cast<uint32_t>(0);
473
474		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
475
476		using ResponseType = DataModel::NullObjectType;
477
478	0	static constexpr bool MustUseTimedInvoke() { return false; }
479		};
480
481		struct DecodableType
482		{
483		public:
484	0	static constexpr CommandId GetCommandId() { return Commands::EnableActionWithDuration::Id; }
485	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
486		static constexpr bool kIsFabricScoped = false;
487
488		uint16_t actionID = static_cast<uint16_t>(0);
489		Optional<uint32_t> invokeID;
490		uint32_t duration = static_cast<uint32_t>(0);
491
492		CHIP_ERROR Decode(TLV::TLVReader & reader);
493		};
494		}; // namespace EnableActionWithDuration
495		namespace DisableAction {
496		enum class Fields : uint8_t
497		{
498		kActionID = 0,
499		kInvokeID = 1,
500		};
501
502		struct Type
503		{
504		public:
505		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
506	0	static constexpr CommandId GetCommandId() { return Commands::DisableAction::Id; }
507	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
508
509		uint16_t actionID = static_cast<uint16_t>(0);
510		Optional<uint32_t> invokeID;
511
512		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
513
514		using ResponseType = DataModel::NullObjectType;
515
516	0	static constexpr bool MustUseTimedInvoke() { return false; }
517		};
518
519		struct DecodableType
520		{
521		public:
522	0	static constexpr CommandId GetCommandId() { return Commands::DisableAction::Id; }
523	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
524		static constexpr bool kIsFabricScoped = false;
525
526		uint16_t actionID = static_cast<uint16_t>(0);
527		Optional<uint32_t> invokeID;
528
529		CHIP_ERROR Decode(TLV::TLVReader & reader);
530		};
531		}; // namespace DisableAction
532		namespace DisableActionWithDuration {
533		enum class Fields : uint8_t
534		{
535		kActionID = 0,
536		kInvokeID = 1,
537		kDuration = 2,
538		};
539
540		struct Type
541		{
542		public:
543		// Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand
544	0	static constexpr CommandId GetCommandId() { return Commands::DisableActionWithDuration::Id; }
545	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
546
547		uint16_t actionID = static_cast<uint16_t>(0);
548		Optional<uint32_t> invokeID;
549		uint32_t duration = static_cast<uint32_t>(0);
550
551		CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const;
552
553		using ResponseType = DataModel::NullObjectType;
554
555	0	static constexpr bool MustUseTimedInvoke() { return false; }
556		};
557
558		struct DecodableType
559		{
560		public:
561	0	static constexpr CommandId GetCommandId() { return Commands::DisableActionWithDuration::Id; }
562	0	static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; }
563		static constexpr bool kIsFabricScoped = false;
564
565		uint16_t actionID = static_cast<uint16_t>(0);
566		Optional<uint32_t> invokeID;
567		uint32_t duration = static_cast<uint32_t>(0);
568
569		CHIP_ERROR Decode(TLV::TLVReader & reader);
570		};
571		}; // namespace DisableActionWithDuration
572		} // namespace Commands
573		} // namespace Actions
574		} // namespace Clusters
575		} // namespace app
576		} // namespace chip