| /* |
| * |
| * 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 |
| |
| #pragma once |
| |
| #include <app-common/zap-generated/enums.h> |
| #include <app-common/zap-generated/ids/Attributes.h> |
| #include <app-common/zap-generated/ids/Clusters.h> |
| #include <app-common/zap-generated/ids/Commands.h> |
| #include <app-common/zap-generated/ids/Events.h> |
| #include <app/ConcreteAttributePath.h> |
| #include <app/EventLoggingTypes.h> |
| #include <app/data-model/DecodableList.h> |
| #include <app/data-model/Decode.h> |
| #include <app/data-model/Encode.h> |
| #include <app/data-model/List.h> |
| #include <app/data-model/NullObject.h> |
| #include <app/util/basic-types.h> |
| #include <lib/core/ClusterEnums.h> |
| #include <lib/support/BitMask.h> |
| #include <protocols/interaction_model/Constants.h> |
| |
| namespace chip { |
| namespace app { |
| namespace Clusters { |
| |
| namespace detail { |
| // Structs shared across multiple clusters. |
| namespace Structs { |
| namespace ApplicationStruct { |
| enum class Fields |
| { |
| kCatalogVendorID = 0, |
| kApplicationID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint16_t catalogVendorID = static_cast<uint16_t>(0); |
| chip::CharSpan applicationID; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| using DecodableType = Type; |
| |
| } // namespace ApplicationStruct |
| namespace LabelStruct { |
| enum class Fields |
| { |
| kLabel = 0, |
| kValue = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::CharSpan label; |
| chip::CharSpan value; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| using DecodableType = Type; |
| |
| } // namespace LabelStruct |
| } // namespace Structs |
| } // namespace detail |
| |
| namespace Globals { |
| namespace Attributes { |
| namespace GeneratedCommandList { |
| struct TypeInfo |
| { |
| using Type = DataModel::List<const chip::CommandId>; |
| using DecodableType = DataModel::DecodableList<chip::CommandId>; |
| using DecodableArgType = const DataModel::DecodableList<chip::CommandId> &; |
| |
| static constexpr AttributeId GetAttributeId() { return Attributes::GeneratedCommandList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace GeneratedCommandList |
| |
| namespace AcceptedCommandList { |
| struct TypeInfo |
| { |
| using Type = DataModel::List<const chip::CommandId>; |
| using DecodableType = DataModel::DecodableList<chip::CommandId>; |
| using DecodableArgType = const DataModel::DecodableList<chip::CommandId> &; |
| |
| static constexpr AttributeId GetAttributeId() { return Attributes::AcceptedCommandList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace AcceptedCommandList |
| |
| namespace AttributeList { |
| struct TypeInfo |
| { |
| using Type = DataModel::List<const chip::AttributeId>; |
| using DecodableType = DataModel::DecodableList<chip::AttributeId>; |
| using DecodableArgType = const DataModel::DecodableList<chip::AttributeId> &; |
| |
| static constexpr AttributeId GetAttributeId() { return Attributes::AttributeList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace AttributeList |
| |
| namespace FeatureMap { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr AttributeId GetAttributeId() { return Attributes::FeatureMap::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace FeatureMap |
| |
| namespace ClusterRevision { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr AttributeId GetAttributeId() { return Attributes::ClusterRevision::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ClusterRevision |
| |
| } // namespace Attributes |
| } // namespace Globals |
| |
| namespace Identify { |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace Identify { |
| struct Type; |
| struct DecodableType; |
| } // namespace Identify |
| |
| namespace TriggerEffect { |
| struct Type; |
| struct DecodableType; |
| } // namespace TriggerEffect |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace Identify { |
| enum class Fields |
| { |
| kIdentifyTime = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::Identify::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| |
| uint16_t identifyTime = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::Identify::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| |
| uint16_t identifyTime = static_cast<uint16_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace Identify |
| namespace TriggerEffect { |
| enum class Fields |
| { |
| kEffectIdentifier = 0, |
| kEffectVariant = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::TriggerEffect::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| |
| IdentifyEffectIdentifier effectIdentifier = static_cast<IdentifyEffectIdentifier>(0); |
| IdentifyEffectVariant effectVariant = static_cast<IdentifyEffectVariant>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::TriggerEffect::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| |
| IdentifyEffectIdentifier effectIdentifier = static_cast<IdentifyEffectIdentifier>(0); |
| IdentifyEffectVariant effectVariant = static_cast<IdentifyEffectVariant>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace TriggerEffect |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace IdentifyTime { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::IdentifyTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace IdentifyTime |
| namespace IdentifyType { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::IdentifyType::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace IdentifyType |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::IdentifyTime::TypeInfo::DecodableType identifyTime = static_cast<uint16_t>(0); |
| Attributes::IdentifyType::TypeInfo::DecodableType identifyType = static_cast<uint8_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 Identify |
| namespace Groups { |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace AddGroup { |
| struct Type; |
| struct DecodableType; |
| } // namespace AddGroup |
| |
| namespace AddGroupResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace AddGroupResponse |
| |
| namespace ViewGroup { |
| struct Type; |
| struct DecodableType; |
| } // namespace ViewGroup |
| |
| namespace ViewGroupResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace ViewGroupResponse |
| |
| namespace GetGroupMembership { |
| struct Type; |
| struct DecodableType; |
| } // namespace GetGroupMembership |
| |
| namespace GetGroupMembershipResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace GetGroupMembershipResponse |
| |
| namespace RemoveGroup { |
| struct Type; |
| struct DecodableType; |
| } // namespace RemoveGroup |
| |
| namespace RemoveGroupResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace RemoveGroupResponse |
| |
| namespace RemoveAllGroups { |
| struct Type; |
| struct DecodableType; |
| } // namespace RemoveAllGroups |
| |
| namespace AddGroupIfIdentifying { |
| struct Type; |
| struct DecodableType; |
| } // namespace AddGroupIfIdentifying |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace AddGroup { |
| enum class Fields |
| { |
| kGroupID = 0, |
| kGroupName = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AddGroup::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| chip::CharSpan groupName; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Groups::Commands::AddGroupResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::AddGroup::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| chip::CharSpan groupName; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AddGroup |
| namespace AddGroupResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AddGroupResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::AddGroupResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AddGroupResponse |
| namespace ViewGroup { |
| enum class Fields |
| { |
| kGroupID = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ViewGroup::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Groups::Commands::ViewGroupResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ViewGroup::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ViewGroup |
| namespace ViewGroupResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| kGroupName = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ViewGroupResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| chip::CharSpan groupName; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ViewGroupResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| chip::CharSpan groupName; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ViewGroupResponse |
| namespace GetGroupMembership { |
| enum class Fields |
| { |
| kGroupList = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::GetGroupMembership::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| DataModel::List<const chip::GroupId> groupList; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Groups::Commands::GetGroupMembershipResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::GetGroupMembership::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| DataModel::DecodableList<chip::GroupId> groupList; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace GetGroupMembership |
| namespace GetGroupMembershipResponse { |
| enum class Fields |
| { |
| kCapacity = 0, |
| kGroupList = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::GetGroupMembershipResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| DataModel::Nullable<uint8_t> capacity; |
| DataModel::List<const chip::GroupId> groupList; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::GetGroupMembershipResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| DataModel::Nullable<uint8_t> capacity; |
| DataModel::DecodableList<chip::GroupId> groupList; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace GetGroupMembershipResponse |
| namespace RemoveGroup { |
| enum class Fields |
| { |
| kGroupID = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RemoveGroup::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Groups::Commands::RemoveGroupResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RemoveGroup::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RemoveGroup |
| namespace RemoveGroupResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RemoveGroupResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RemoveGroupResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RemoveGroupResponse |
| namespace RemoveAllGroups { |
| enum class Fields |
| { |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RemoveAllGroups::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RemoveAllGroups::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RemoveAllGroups |
| namespace AddGroupIfIdentifying { |
| enum class Fields |
| { |
| kGroupID = 0, |
| kGroupName = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AddGroupIfIdentifying::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| chip::CharSpan groupName; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::AddGroupIfIdentifying::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| chip::CharSpan groupName; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AddGroupIfIdentifying |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace NameSupport { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NameSupport::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace NameSupport |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::NameSupport::TypeInfo::DecodableType nameSupport = static_cast<uint8_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 Groups |
| namespace Scenes { |
| namespace Structs { |
| namespace AttributeValuePair { |
| enum class Fields |
| { |
| kAttributeID = 0, |
| kAttributeValue = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| Optional<chip::AttributeId> attributeID; |
| DataModel::List<const uint8_t> attributeValue; |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| Optional<chip::AttributeId> attributeID; |
| DataModel::DecodableList<uint8_t> attributeValue; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| }; |
| |
| } // namespace AttributeValuePair |
| namespace ExtensionFieldSet { |
| enum class Fields |
| { |
| kClusterID = 0, |
| kAttributeValueList = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::ClusterId clusterID = static_cast<chip::ClusterId>(0); |
| DataModel::List<const Structs::AttributeValuePair::Type> attributeValueList; |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| chip::ClusterId clusterID = static_cast<chip::ClusterId>(0); |
| DataModel::DecodableList<Structs::AttributeValuePair::DecodableType> attributeValueList; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| }; |
| |
| } // namespace ExtensionFieldSet |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace AddScene { |
| struct Type; |
| struct DecodableType; |
| } // namespace AddScene |
| |
| namespace AddSceneResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace AddSceneResponse |
| |
| namespace ViewScene { |
| struct Type; |
| struct DecodableType; |
| } // namespace ViewScene |
| |
| namespace ViewSceneResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace ViewSceneResponse |
| |
| namespace RemoveScene { |
| struct Type; |
| struct DecodableType; |
| } // namespace RemoveScene |
| |
| namespace RemoveSceneResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace RemoveSceneResponse |
| |
| namespace RemoveAllScenes { |
| struct Type; |
| struct DecodableType; |
| } // namespace RemoveAllScenes |
| |
| namespace RemoveAllScenesResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace RemoveAllScenesResponse |
| |
| namespace StoreScene { |
| struct Type; |
| struct DecodableType; |
| } // namespace StoreScene |
| |
| namespace StoreSceneResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace StoreSceneResponse |
| |
| namespace RecallScene { |
| struct Type; |
| struct DecodableType; |
| } // namespace RecallScene |
| |
| namespace GetSceneMembership { |
| struct Type; |
| struct DecodableType; |
| } // namespace GetSceneMembership |
| |
| namespace GetSceneMembershipResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace GetSceneMembershipResponse |
| |
| namespace EnhancedAddScene { |
| struct Type; |
| struct DecodableType; |
| } // namespace EnhancedAddScene |
| |
| namespace EnhancedAddSceneResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace EnhancedAddSceneResponse |
| |
| namespace EnhancedViewScene { |
| struct Type; |
| struct DecodableType; |
| } // namespace EnhancedViewScene |
| |
| namespace EnhancedViewSceneResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace EnhancedViewSceneResponse |
| |
| namespace CopyScene { |
| struct Type; |
| struct DecodableType; |
| } // namespace CopyScene |
| |
| namespace CopySceneResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace CopySceneResponse |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace AddScene { |
| enum class Fields |
| { |
| kGroupID = 0, |
| kSceneID = 1, |
| kTransitionTime = 2, |
| kSceneName = 3, |
| kExtensionFieldSets = 4, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AddScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| uint16_t transitionTime = static_cast<uint16_t>(0); |
| chip::CharSpan sceneName; |
| DataModel::List<const Structs::ExtensionFieldSet::Type> extensionFieldSets; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Scenes::Commands::AddSceneResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::AddScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| uint16_t transitionTime = static_cast<uint16_t>(0); |
| chip::CharSpan sceneName; |
| DataModel::DecodableList<Structs::ExtensionFieldSet::DecodableType> extensionFieldSets; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AddScene |
| namespace AddSceneResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| kSceneID = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AddSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::AddSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AddSceneResponse |
| namespace ViewScene { |
| enum class Fields |
| { |
| kGroupID = 0, |
| kSceneID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ViewScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Scenes::Commands::ViewSceneResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ViewScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ViewScene |
| namespace ViewSceneResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| kSceneID = 2, |
| kTransitionTime = 3, |
| kSceneName = 4, |
| kExtensionFieldSets = 5, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ViewSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| Optional<uint16_t> transitionTime; |
| Optional<chip::CharSpan> sceneName; |
| Optional<DataModel::List<const Structs::ExtensionFieldSet::Type>> extensionFieldSets; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ViewSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| Optional<uint16_t> transitionTime; |
| Optional<chip::CharSpan> sceneName; |
| Optional<DataModel::DecodableList<Structs::ExtensionFieldSet::DecodableType>> extensionFieldSets; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ViewSceneResponse |
| namespace RemoveScene { |
| enum class Fields |
| { |
| kGroupID = 0, |
| kSceneID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RemoveScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Scenes::Commands::RemoveSceneResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RemoveScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RemoveScene |
| namespace RemoveSceneResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| kSceneID = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RemoveSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RemoveSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RemoveSceneResponse |
| namespace RemoveAllScenes { |
| enum class Fields |
| { |
| kGroupID = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RemoveAllScenes::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Scenes::Commands::RemoveAllScenesResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RemoveAllScenes::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RemoveAllScenes |
| namespace RemoveAllScenesResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RemoveAllScenesResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RemoveAllScenesResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RemoveAllScenesResponse |
| namespace StoreScene { |
| enum class Fields |
| { |
| kGroupID = 0, |
| kSceneID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::StoreScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Scenes::Commands::StoreSceneResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::StoreScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace StoreScene |
| namespace StoreSceneResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| kSceneID = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::StoreSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::StoreSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace StoreSceneResponse |
| namespace RecallScene { |
| enum class Fields |
| { |
| kGroupID = 0, |
| kSceneID = 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::RecallScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| Optional<DataModel::Nullable<uint16_t>> transitionTime; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RecallScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| Optional<DataModel::Nullable<uint16_t>> transitionTime; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RecallScene |
| namespace GetSceneMembership { |
| enum class Fields |
| { |
| kGroupID = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::GetSceneMembership::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Scenes::Commands::GetSceneMembershipResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::GetSceneMembership::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace GetSceneMembership |
| namespace GetSceneMembershipResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kCapacity = 1, |
| kGroupID = 2, |
| kSceneList = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::GetSceneMembershipResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint8_t> capacity; |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| Optional<DataModel::List<const uint8_t>> sceneList; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::GetSceneMembershipResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint8_t> capacity; |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| Optional<DataModel::DecodableList<uint8_t>> sceneList; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace GetSceneMembershipResponse |
| namespace EnhancedAddScene { |
| enum class Fields |
| { |
| kGroupID = 0, |
| kSceneID = 1, |
| kTransitionTime = 2, |
| kSceneName = 3, |
| kExtensionFieldSets = 4, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::EnhancedAddScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| uint16_t transitionTime = static_cast<uint16_t>(0); |
| chip::CharSpan sceneName; |
| DataModel::List<const Structs::ExtensionFieldSet::Type> extensionFieldSets; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Scenes::Commands::EnhancedAddSceneResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::EnhancedAddScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| uint16_t transitionTime = static_cast<uint16_t>(0); |
| chip::CharSpan sceneName; |
| DataModel::DecodableList<Structs::ExtensionFieldSet::DecodableType> extensionFieldSets; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace EnhancedAddScene |
| namespace EnhancedAddSceneResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| kSceneID = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::EnhancedAddSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::EnhancedAddSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace EnhancedAddSceneResponse |
| namespace EnhancedViewScene { |
| enum class Fields |
| { |
| kGroupID = 0, |
| kSceneID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::EnhancedViewScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Scenes::Commands::EnhancedViewSceneResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::EnhancedViewScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace EnhancedViewScene |
| namespace EnhancedViewSceneResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupID = 1, |
| kSceneID = 2, |
| kTransitionTime = 3, |
| kSceneName = 4, |
| kExtensionFieldSets = 5, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::EnhancedViewSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| Optional<uint16_t> transitionTime; |
| Optional<chip::CharSpan> sceneName; |
| Optional<DataModel::List<const Structs::ExtensionFieldSet::Type>> extensionFieldSets; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::EnhancedViewSceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupID = static_cast<chip::GroupId>(0); |
| uint8_t sceneID = static_cast<uint8_t>(0); |
| Optional<uint16_t> transitionTime; |
| Optional<chip::CharSpan> sceneName; |
| Optional<DataModel::DecodableList<Structs::ExtensionFieldSet::DecodableType>> extensionFieldSets; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace EnhancedViewSceneResponse |
| namespace CopyScene { |
| enum class Fields |
| { |
| kMode = 0, |
| kGroupIdentifierFrom = 1, |
| kSceneIdentifierFrom = 2, |
| kGroupIdentifierTo = 3, |
| kSceneIdentifierTo = 4, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::CopyScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::BitMask<ScenesCopyMode> mode = static_cast<chip::BitMask<ScenesCopyMode>>(0); |
| chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0); |
| chip::GroupId groupIdentifierTo = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdentifierTo = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::Scenes::Commands::CopySceneResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::CopyScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| chip::BitMask<ScenesCopyMode> mode = static_cast<chip::BitMask<ScenesCopyMode>>(0); |
| chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0); |
| chip::GroupId groupIdentifierTo = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdentifierTo = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace CopyScene |
| namespace CopySceneResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupIdentifierFrom = 1, |
| kSceneIdentifierFrom = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::CopySceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::CopySceneResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| uint8_t status = static_cast<uint8_t>(0); |
| chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace CopySceneResponse |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace SceneCount { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SceneCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SceneCount |
| namespace CurrentScene { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentScene::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentScene |
| namespace CurrentGroup { |
| struct TypeInfo |
| { |
| using Type = chip::GroupId; |
| using DecodableType = chip::GroupId; |
| using DecodableArgType = chip::GroupId; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentGroup::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentGroup |
| namespace SceneValid { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SceneValid::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SceneValid |
| namespace NameSupport { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NameSupport::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace NameSupport |
| namespace LastConfiguredBy { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::NodeId>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::NodeId>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::NodeId> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LastConfiguredBy::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LastConfiguredBy |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::SceneCount::TypeInfo::DecodableType sceneCount = static_cast<uint8_t>(0); |
| Attributes::CurrentScene::TypeInfo::DecodableType currentScene = static_cast<uint8_t>(0); |
| Attributes::CurrentGroup::TypeInfo::DecodableType currentGroup = static_cast<chip::GroupId>(0); |
| Attributes::SceneValid::TypeInfo::DecodableType sceneValid = static_cast<bool>(0); |
| Attributes::NameSupport::TypeInfo::DecodableType nameSupport = static_cast<uint8_t>(0); |
| Attributes::LastConfiguredBy::TypeInfo::DecodableType lastConfiguredBy; |
| 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 Scenes |
| namespace OnOff { |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace Off { |
| struct Type; |
| struct DecodableType; |
| } // namespace Off |
| |
| namespace On { |
| struct Type; |
| struct DecodableType; |
| } // namespace On |
| |
| namespace Toggle { |
| struct Type; |
| struct DecodableType; |
| } // namespace Toggle |
| |
| namespace OffWithEffect { |
| struct Type; |
| struct DecodableType; |
| } // namespace OffWithEffect |
| |
| namespace OnWithRecallGlobalScene { |
| struct Type; |
| struct DecodableType; |
| } // namespace OnWithRecallGlobalScene |
| |
| namespace OnWithTimedOff { |
| struct Type; |
| struct DecodableType; |
| } // namespace OnWithTimedOff |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace Off { |
| enum class Fields |
| { |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::Off::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::Off::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace Off |
| namespace On { |
| enum class Fields |
| { |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::On::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::On::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace On |
| namespace Toggle { |
| enum class Fields |
| { |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::Toggle::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::Toggle::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace Toggle |
| namespace OffWithEffect { |
| enum class Fields |
| { |
| kEffectIdentifier = 0, |
| kEffectVariant = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::OffWithEffect::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| OnOffEffectIdentifier effectIdentifier = static_cast<OnOffEffectIdentifier>(0); |
| OnOffDelayedAllOffEffectVariant effectVariant = static_cast<OnOffDelayedAllOffEffectVariant>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::OffWithEffect::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| OnOffEffectIdentifier effectIdentifier = static_cast<OnOffEffectIdentifier>(0); |
| OnOffDelayedAllOffEffectVariant effectVariant = static_cast<OnOffDelayedAllOffEffectVariant>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace OffWithEffect |
| namespace OnWithRecallGlobalScene { |
| enum class Fields |
| { |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::OnWithRecallGlobalScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::OnWithRecallGlobalScene::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace OnWithRecallGlobalScene |
| namespace OnWithTimedOff { |
| enum class Fields |
| { |
| kOnOffControl = 0, |
| kOnTime = 1, |
| kOffWaitTime = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::OnWithTimedOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| chip::BitMask<OnOffControl> onOffControl = static_cast<chip::BitMask<OnOffControl>>(0); |
| uint16_t onTime = static_cast<uint16_t>(0); |
| uint16_t offWaitTime = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::OnWithTimedOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| chip::BitMask<OnOffControl> onOffControl = static_cast<chip::BitMask<OnOffControl>>(0); |
| uint16_t onTime = static_cast<uint16_t>(0); |
| uint16_t offWaitTime = static_cast<uint16_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace OnWithTimedOff |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace OnOff { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OnOff::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OnOff |
| namespace GlobalSceneControl { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::GlobalSceneControl::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace GlobalSceneControl |
| namespace OnTime { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OnTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OnTime |
| namespace OffWaitTime { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OffWaitTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OffWaitTime |
| namespace StartUpOnOff { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffStartUpOnOff>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffStartUpOnOff>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffStartUpOnOff> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::StartUpOnOff::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace StartUpOnOff |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::OnOff::TypeInfo::DecodableType onOff = static_cast<bool>(0); |
| Attributes::GlobalSceneControl::TypeInfo::DecodableType globalSceneControl = static_cast<bool>(0); |
| Attributes::OnTime::TypeInfo::DecodableType onTime = static_cast<uint16_t>(0); |
| Attributes::OffWaitTime::TypeInfo::DecodableType offWaitTime = static_cast<uint16_t>(0); |
| Attributes::StartUpOnOff::TypeInfo::DecodableType startUpOnOff; |
| 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 OnOff |
| namespace OnOffSwitchConfiguration { |
| |
| namespace Attributes { |
| |
| namespace SwitchType { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOffSwitchConfiguration::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SwitchType::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SwitchType |
| namespace SwitchActions { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOffSwitchConfiguration::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SwitchActions::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SwitchActions |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOffSwitchConfiguration::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOffSwitchConfiguration::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOffSwitchConfiguration::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOffSwitchConfiguration::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOffSwitchConfiguration::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OnOffSwitchConfiguration::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::SwitchType::TypeInfo::DecodableType switchType = static_cast<uint8_t>(0); |
| Attributes::SwitchActions::TypeInfo::DecodableType switchActions = static_cast<uint8_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 OnOffSwitchConfiguration |
| namespace LevelControl { |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace MoveToLevel { |
| struct Type; |
| struct DecodableType; |
| } // namespace MoveToLevel |
| |
| namespace Move { |
| struct Type; |
| struct DecodableType; |
| } // namespace Move |
| |
| namespace Step { |
| struct Type; |
| struct DecodableType; |
| } // namespace Step |
| |
| namespace Stop { |
| struct Type; |
| struct DecodableType; |
| } // namespace Stop |
| |
| namespace MoveToLevelWithOnOff { |
| struct Type; |
| struct DecodableType; |
| } // namespace MoveToLevelWithOnOff |
| |
| namespace MoveWithOnOff { |
| struct Type; |
| struct DecodableType; |
| } // namespace MoveWithOnOff |
| |
| namespace StepWithOnOff { |
| struct Type; |
| struct DecodableType; |
| } // namespace StepWithOnOff |
| |
| namespace StopWithOnOff { |
| struct Type; |
| struct DecodableType; |
| } // namespace StopWithOnOff |
| |
| namespace MoveToClosestFrequency { |
| struct Type; |
| struct DecodableType; |
| } // namespace MoveToClosestFrequency |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace MoveToLevel { |
| enum class Fields |
| { |
| kLevel = 0, |
| kTransitionTime = 1, |
| kOptionsMask = 2, |
| kOptionsOverride = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::MoveToLevel::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| uint8_t level = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint16_t> transitionTime; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::MoveToLevel::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| uint8_t level = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint16_t> transitionTime; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace MoveToLevel |
| namespace Move { |
| enum class Fields |
| { |
| kMoveMode = 0, |
| kRate = 1, |
| kOptionsMask = 2, |
| kOptionsOverride = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::Move::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| MoveMode moveMode = static_cast<MoveMode>(0); |
| DataModel::Nullable<uint8_t> rate; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::Move::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| MoveMode moveMode = static_cast<MoveMode>(0); |
| DataModel::Nullable<uint8_t> rate; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace Move |
| namespace Step { |
| enum class Fields |
| { |
| kStepMode = 0, |
| kStepSize = 1, |
| kTransitionTime = 2, |
| kOptionsMask = 3, |
| kOptionsOverride = 4, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::Step::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| StepMode stepMode = static_cast<StepMode>(0); |
| uint8_t stepSize = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint16_t> transitionTime; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::Step::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| StepMode stepMode = static_cast<StepMode>(0); |
| uint8_t stepSize = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint16_t> transitionTime; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace Step |
| namespace Stop { |
| enum class Fields |
| { |
| kOptionsMask = 0, |
| kOptionsOverride = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::Stop::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::Stop::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace Stop |
| namespace MoveToLevelWithOnOff { |
| enum class Fields |
| { |
| kLevel = 0, |
| kTransitionTime = 1, |
| kOptionsMask = 2, |
| kOptionsOverride = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::MoveToLevelWithOnOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| uint8_t level = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint16_t> transitionTime; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::MoveToLevelWithOnOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| uint8_t level = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint16_t> transitionTime; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace MoveToLevelWithOnOff |
| namespace MoveWithOnOff { |
| enum class Fields |
| { |
| kMoveMode = 0, |
| kRate = 1, |
| kOptionsMask = 2, |
| kOptionsOverride = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::MoveWithOnOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| MoveMode moveMode = static_cast<MoveMode>(0); |
| DataModel::Nullable<uint8_t> rate; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::MoveWithOnOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| MoveMode moveMode = static_cast<MoveMode>(0); |
| DataModel::Nullable<uint8_t> rate; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace MoveWithOnOff |
| namespace StepWithOnOff { |
| enum class Fields |
| { |
| kStepMode = 0, |
| kStepSize = 1, |
| kTransitionTime = 2, |
| kOptionsMask = 3, |
| kOptionsOverride = 4, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::StepWithOnOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| StepMode stepMode = static_cast<StepMode>(0); |
| uint8_t stepSize = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint16_t> transitionTime; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::StepWithOnOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| StepMode stepMode = static_cast<StepMode>(0); |
| uint8_t stepSize = static_cast<uint8_t>(0); |
| DataModel::Nullable<uint16_t> transitionTime; |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace StepWithOnOff |
| namespace StopWithOnOff { |
| enum class Fields |
| { |
| kOptionsMask = 0, |
| kOptionsOverride = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::StopWithOnOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::StopWithOnOff::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| chip::BitMask<LevelControlOptions> optionsMask = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| chip::BitMask<LevelControlOptions> optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace StopWithOnOff |
| namespace MoveToClosestFrequency { |
| enum class Fields |
| { |
| kFrequency = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::MoveToClosestFrequency::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| uint16_t frequency = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::MoveToClosestFrequency::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| uint16_t frequency = static_cast<uint16_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace MoveToClosestFrequency |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace CurrentLevel { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint8_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint8_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint8_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentLevel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentLevel |
| namespace RemainingTime { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RemainingTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RemainingTime |
| namespace MinLevel { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::MinLevel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace MinLevel |
| namespace MaxLevel { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::MaxLevel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace MaxLevel |
| namespace CurrentFrequency { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentFrequency::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentFrequency |
| namespace MinFrequency { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
