| /* |
| * |
| * 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 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, |
| kGroupIdFrom = 1, |
| kSceneIdFrom = 2, |
| kGroupIdTo = 3, |
| kSceneIdTo = 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 groupIdFrom = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdFrom = static_cast<uint8_t>(0); |
| chip::GroupId groupIdTo = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdTo = 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 groupIdFrom = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdFrom = static_cast<uint8_t>(0); |
| chip::GroupId groupIdTo = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdTo = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace CopyScene |
| namespace CopySceneResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kGroupIdFrom = 1, |
| kSceneIdFrom = 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 groupIdFrom = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdFrom = 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 groupIdFrom = static_cast<chip::GroupId>(0); |
| uint8_t sceneIdFrom = 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 |
| { |
| kEffectId = 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 effectId = 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 effectId = 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; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::MinFrequency::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace MinFrequency |
| namespace MaxFrequency { |
| 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::MaxFrequency::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace MaxFrequency |
| namespace Options { |
| struct TypeInfo |
| { |
| using Type = chip::BitMask<chip::app::Clusters::LevelControl::LevelControlOptions>; |
| using DecodableType = chip::BitMask<chip::app::Clusters::LevelControl::LevelControlOptions>; |
| using DecodableArgType = chip::BitMask<chip::app::Clusters::LevelControl::LevelControlOptions>; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Options::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Options |
| namespace OnOffTransitionTime { |
| 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::OnOffTransitionTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OnOffTransitionTime |
| namespace OnLevel { |
| 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::OnLevel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OnLevel |
| namespace OnTransitionTime { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OnTransitionTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OnTransitionTime |
| namespace OffTransitionTime { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OffTransitionTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OffTransitionTime |
| namespace DefaultMoveRate { |
| 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::DefaultMoveRate::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace DefaultMoveRate |
| namespace StartUpCurrentLevel { |
| 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::StartUpCurrentLevel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace StartUpCurrentLevel |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::CurrentLevel::TypeInfo::DecodableType currentLevel; |
| Attributes::RemainingTime::TypeInfo::DecodableType remainingTime = static_cast<uint16_t>(0); |
| Attributes::MinLevel::TypeInfo::DecodableType minLevel = static_cast<uint8_t>(0); |
| Attributes::MaxLevel::TypeInfo::DecodableType maxLevel = static_cast<uint8_t>(0); |
| Attributes::CurrentFrequency::TypeInfo::DecodableType currentFrequency = static_cast<uint16_t>(0); |
| Attributes::MinFrequency::TypeInfo::DecodableType minFrequency = static_cast<uint16_t>(0); |
| Attributes::MaxFrequency::TypeInfo::DecodableType maxFrequency = static_cast<uint16_t>(0); |
| Attributes::Options::TypeInfo::DecodableType options = |
| static_cast<chip::BitMask<chip::app::Clusters::LevelControl::LevelControlOptions>>(0); |
| Attributes::OnOffTransitionTime::TypeInfo::DecodableType onOffTransitionTime = static_cast<uint16_t>(0); |
| Attributes::OnLevel::TypeInfo::DecodableType onLevel; |
| Attributes::OnTransitionTime::TypeInfo::DecodableType onTransitionTime; |
| Attributes::OffTransitionTime::TypeInfo::DecodableType offTransitionTime; |
| Attributes::DefaultMoveRate::TypeInfo::DecodableType defaultMoveRate; |
| Attributes::StartUpCurrentLevel::TypeInfo::DecodableType startUpCurrentLevel; |
| 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 LevelControl |
| namespace BinaryInputBasic { |
| |
| namespace Attributes { |
| |
| namespace ActiveText { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveText::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 16; } |
| }; |
| } // namespace ActiveText |
| namespace Description { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Description::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 16; } |
| }; |
| } // namespace Description |
| namespace InactiveText { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::InactiveText::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 16; } |
| }; |
| } // namespace InactiveText |
| namespace OutOfService { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OutOfService::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OutOfService |
| namespace Polarity { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Polarity::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Polarity |
| namespace PresentValue { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PresentValue::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PresentValue |
| namespace Reliability { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Reliability::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Reliability |
| namespace StatusFlags { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::StatusFlags::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace StatusFlags |
| namespace ApplicationType { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ApplicationType::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ApplicationType |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::ActiveText::TypeInfo::DecodableType activeText; |
| Attributes::Description::TypeInfo::DecodableType description; |
| Attributes::InactiveText::TypeInfo::DecodableType inactiveText; |
| Attributes::OutOfService::TypeInfo::DecodableType outOfService = static_cast<bool>(0); |
| Attributes::Polarity::TypeInfo::DecodableType polarity = static_cast<uint8_t>(0); |
| Attributes::PresentValue::TypeInfo::DecodableType presentValue = static_cast<bool>(0); |
| Attributes::Reliability::TypeInfo::DecodableType reliability = static_cast<uint8_t>(0); |
| Attributes::StatusFlags::TypeInfo::DecodableType statusFlags = static_cast<uint8_t>(0); |
| Attributes::ApplicationType::TypeInfo::DecodableType applicationType = static_cast<uint32_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 BinaryInputBasic |
| namespace PulseWidthModulation { |
| |
| namespace Attributes { |
| |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| 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 PulseWidthModulation |
| namespace Descriptor { |
| namespace Structs { |
| namespace DeviceTypeStruct { |
| enum class Fields |
| { |
| kType = 0, |
| kRevision = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::DeviceTypeId type = static_cast<chip::DeviceTypeId>(0); |
| uint16_t revision = static_cast<uint16_t>(0); |
| |
| 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 DeviceTypeStruct |
| } // namespace Structs |
| |
| namespace Attributes { |
| |
| namespace DeviceTypeList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::DeviceTypeList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace DeviceTypeList |
| namespace ServerList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::ClusterId>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::ClusterId>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ClusterId> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ServerList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ServerList |
| namespace ClientList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::ClusterId>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::ClusterId>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ClusterId> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ClientList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ClientList |
| namespace PartsList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::EndpointId>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::EndpointId>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<chip::EndpointId> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PartsList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PartsList |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::DeviceTypeList::TypeInfo::DecodableType deviceTypeList; |
| Attributes::ServerList::TypeInfo::DecodableType serverList; |
| Attributes::ClientList::TypeInfo::DecodableType clientList; |
| Attributes::PartsList::TypeInfo::DecodableType partsList; |
| 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 Descriptor |
| namespace Binding { |
| namespace Structs { |
| namespace TargetStruct { |
| enum class Fields |
| { |
| kNode = 1, |
| kGroup = 2, |
| kEndpoint = 3, |
| kCluster = 4, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| Optional<chip::NodeId> node; |
| Optional<chip::GroupId> group; |
| Optional<chip::EndpointId> endpoint; |
| Optional<chip::ClusterId> cluster; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| |
| CHIP_ERROR EncodeForWrite(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| CHIP_ERROR EncodeForRead(TLV::TLVWriter & writer, TLV::Tag tag, FabricIndex accessingFabricIndex) const; |
| |
| private: |
| CHIP_ERROR DoEncode(TLV::TLVWriter & writer, TLV::Tag tag, const Optional<FabricIndex> & accessingFabricIndex) const; |
| }; |
| |
| using DecodableType = Type; |
| |
| } // namespace TargetStruct |
| } // namespace Structs |
| |
| namespace Attributes { |
| |
| namespace Binding { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::Binding::Structs::TargetStruct::Type>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::Binding::Structs::TargetStruct::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::Binding::Structs::TargetStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Binding::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Binding |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::Binding::TypeInfo::DecodableType binding; |
| 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 Binding |
| namespace AccessControl { |
| namespace Structs { |
| namespace Target { |
| enum class Fields |
| { |
| kCluster = 0, |
| kEndpoint = 1, |
| kDeviceType = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| DataModel::Nullable<chip::ClusterId> cluster; |
| DataModel::Nullable<chip::EndpointId> endpoint; |
| DataModel::Nullable<chip::DeviceTypeId> deviceType; |
| |
| 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 Target |
| namespace AccessControlEntry { |
| enum class Fields |
| { |
| kPrivilege = 1, |
| kAuthMode = 2, |
| kSubjects = 3, |
| kTargets = 4, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| Privilege privilege = static_cast<Privilege>(0); |
| AuthMode authMode = static_cast<AuthMode>(0); |
| DataModel::Nullable<DataModel::List<const uint64_t>> subjects; |
| DataModel::Nullable<DataModel::List<const Structs::Target::Type>> targets; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| |
| CHIP_ERROR EncodeForWrite(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| CHIP_ERROR EncodeForRead(TLV::TLVWriter & writer, TLV::Tag tag, FabricIndex accessingFabricIndex) const; |
| |
| private: |
| CHIP_ERROR DoEncode(TLV::TLVWriter & writer, TLV::Tag tag, const Optional<FabricIndex> & accessingFabricIndex) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| Privilege privilege = static_cast<Privilege>(0); |
| AuthMode authMode = static_cast<AuthMode>(0); |
| DataModel::Nullable<DataModel::DecodableList<uint64_t>> subjects; |
| DataModel::Nullable<DataModel::DecodableList<Structs::Target::DecodableType>> targets; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| }; |
| |
| } // namespace AccessControlEntry |
| namespace ExtensionEntry { |
| enum class Fields |
| { |
| kData = 1, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::ByteSpan data; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| |
| CHIP_ERROR EncodeForWrite(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| CHIP_ERROR EncodeForRead(TLV::TLVWriter & writer, TLV::Tag tag, FabricIndex accessingFabricIndex) const; |
| |
| private: |
| CHIP_ERROR DoEncode(TLV::TLVWriter & writer, TLV::Tag tag, const Optional<FabricIndex> & accessingFabricIndex) const; |
| }; |
| |
| using DecodableType = Type; |
| |
| } // namespace ExtensionEntry |
| } // namespace Structs |
| |
| namespace Attributes { |
| |
| namespace Acl { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessControlEntry::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::AccessControlEntry::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::AccessControlEntry::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Acl::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Acl |
| namespace Extension { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::ExtensionEntry::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::ExtensionEntry::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::ExtensionEntry::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Extension::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Extension |
| namespace SubjectsPerAccessControlEntry { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SubjectsPerAccessControlEntry::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SubjectsPerAccessControlEntry |
| namespace TargetsPerAccessControlEntry { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TargetsPerAccessControlEntry::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TargetsPerAccessControlEntry |
| namespace AccessControlEntriesPerFabric { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::AccessControlEntriesPerFabric::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace AccessControlEntriesPerFabric |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::Acl::TypeInfo::DecodableType acl; |
| Attributes::Extension::TypeInfo::DecodableType extension; |
| Attributes::SubjectsPerAccessControlEntry::TypeInfo::DecodableType subjectsPerAccessControlEntry = static_cast<uint16_t>(0); |
| Attributes::TargetsPerAccessControlEntry::TypeInfo::DecodableType targetsPerAccessControlEntry = static_cast<uint16_t>(0); |
| Attributes::AccessControlEntriesPerFabric::TypeInfo::DecodableType accessControlEntriesPerFabric = static_cast<uint16_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 Events { |
| namespace AccessControlEntryChanged { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kAdminNodeID = 1, |
| kAdminPasscodeID = 2, |
| kChangeType = 3, |
| kLatestValue = 4, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::AccessControlEntryChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| static constexpr bool kIsFabricScoped = true; |
| |
| DataModel::Nullable<chip::NodeId> adminNodeID; |
| DataModel::Nullable<uint16_t> adminPasscodeID; |
| ChangeTypeEnum changeType = static_cast<ChangeTypeEnum>(0); |
| DataModel::Nullable<Structs::AccessControlEntry::Type> latestValue; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::AccessControlEntryChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| |
| DataModel::Nullable<chip::NodeId> adminNodeID; |
| DataModel::Nullable<uint16_t> adminPasscodeID; |
| ChangeTypeEnum changeType = static_cast<ChangeTypeEnum>(0); |
| DataModel::Nullable<Structs::AccessControlEntry::DecodableType> latestValue; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace AccessControlEntryChanged |
| namespace AccessControlExtensionChanged { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kAdminNodeID = 1, |
| kAdminPasscodeID = 2, |
| kChangeType = 3, |
| kLatestValue = 4, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::AccessControlExtensionChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| static constexpr bool kIsFabricScoped = true; |
| |
| DataModel::Nullable<chip::NodeId> adminNodeID; |
| DataModel::Nullable<uint16_t> adminPasscodeID; |
| ChangeTypeEnum changeType = static_cast<ChangeTypeEnum>(0); |
| DataModel::Nullable<Structs::ExtensionEntry::Type> latestValue; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::AccessControlExtensionChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } |
| |
| DataModel::Nullable<chip::NodeId> adminNodeID; |
| DataModel::Nullable<uint16_t> adminPasscodeID; |
| ChangeTypeEnum changeType = static_cast<ChangeTypeEnum>(0); |
| DataModel::Nullable<Structs::ExtensionEntry::DecodableType> latestValue; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace AccessControlExtensionChanged |
| } // namespace Events |
| } // namespace AccessControl |
| namespace Actions { |
| namespace Structs { |
| namespace ActionStruct { |
| enum class Fields |
| { |
| kActionID = 0, |
| kName = 1, |
| kType = 2, |
| kEndpointListID = 3, |
| kSupportedCommands = 4, |
| kState = 5, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint16_t actionID = static_cast<uint16_t>(0); |
| chip::CharSpan name; |
| ActionTypeEnum type = static_cast<ActionTypeEnum>(0); |
| uint16_t endpointListID = static_cast<uint16_t>(0); |
| chip::BitMask<CommandBits> supportedCommands = static_cast<chip::BitMask<CommandBits>>(0); |
| ActionStateEnum state = static_cast<ActionStateEnum>(0); |
| |
| 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 ActionStruct |
| namespace EndpointListStruct { |
| enum class Fields |
| { |
| kEndpointListID = 0, |
| kName = 1, |
| kType = 2, |
| kEndpoints = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint16_t endpointListID = static_cast<uint16_t>(0); |
| chip::CharSpan name; |
| EndpointListTypeEnum type = static_cast<EndpointListTypeEnum>(0); |
| DataModel::List<const chip::EndpointId> endpoints; |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| uint16_t endpointListID = static_cast<uint16_t>(0); |
| chip::CharSpan name; |
| EndpointListTypeEnum type = static_cast<EndpointListTypeEnum>(0); |
| DataModel::DecodableList<chip::EndpointId> endpoints; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| }; |
| |
| } // namespace EndpointListStruct |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace InstantAction { |
| struct Type; |
| struct DecodableType; |
| } // namespace InstantAction |
| |
| namespace InstantActionWithTransition { |
| struct Type; |
| struct DecodableType; |
| } // namespace InstantActionWithTransition |
| |
| namespace StartAction { |
| struct Type; |
| struct DecodableType; |
| } // namespace StartAction |
| |
| namespace StartActionWithDuration { |
| struct Type; |
| struct DecodableType; |
| } // namespace StartActionWithDuration |
| |
| namespace StopAction { |
| struct Type; |
| struct DecodableType; |
| } // namespace StopAction |
| |
| namespace PauseAction { |
| struct Type; |
| struct DecodableType; |
| } // namespace PauseAction |
| |
| namespace PauseActionWithDuration { |
| struct Type; |
| struct DecodableType; |
| } // namespace PauseActionWithDuration |
| |
| namespace ResumeAction { |
| struct Type; |
| struct DecodableType; |
| } // namespace ResumeAction |
| |
| namespace EnableAction { |
| struct Type; |
| struct DecodableType; |
| } // namespace EnableAction |
| |
| namespace EnableActionWithDuration { |
| struct Type; |
| struct DecodableType; |
| } // namespace EnableActionWithDuration |
| |
| namespace DisableAction { |
| struct Type; |
| struct DecodableType; |
| } // namespace DisableAction |
| |
| namespace DisableActionWithDuration { |
| struct Type; |
| struct DecodableType; |
| } // namespace DisableActionWithDuration |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace InstantAction { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::InstantAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::InstantAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace InstantAction |
| namespace InstantActionWithTransition { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| kTransitionTime = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::InstantActionWithTransition::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint16_t transitionTime = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::InstantActionWithTransition::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint16_t transitionTime = static_cast<uint16_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace InstantActionWithTransition |
| namespace StartAction { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::StartAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::StartAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace StartAction |
| namespace StartActionWithDuration { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| kDuration = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::StartActionWithDuration::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint32_t duration = static_cast<uint32_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::StartActionWithDuration::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint32_t duration = static_cast<uint32_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace StartActionWithDuration |
| namespace StopAction { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::StopAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::StopAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace StopAction |
| namespace PauseAction { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::PauseAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::PauseAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace PauseAction |
| namespace PauseActionWithDuration { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| kDuration = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::PauseActionWithDuration::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint32_t duration = static_cast<uint32_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::PauseActionWithDuration::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint32_t duration = static_cast<uint32_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace PauseActionWithDuration |
| namespace ResumeAction { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ResumeAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ResumeAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ResumeAction |
| namespace EnableAction { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::EnableAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::EnableAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace EnableAction |
| namespace EnableActionWithDuration { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| kDuration = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::EnableActionWithDuration::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint32_t duration = static_cast<uint32_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::EnableActionWithDuration::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint32_t duration = static_cast<uint32_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace EnableActionWithDuration |
| namespace DisableAction { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::DisableAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::DisableAction::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace DisableAction |
| namespace DisableActionWithDuration { |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| kDuration = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::DisableActionWithDuration::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint32_t duration = static_cast<uint32_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::DisableActionWithDuration::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| Optional<uint32_t> invokeID; |
| uint32_t duration = static_cast<uint32_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace DisableActionWithDuration |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace ActionList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::Actions::Structs::ActionStruct::Type>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::ActionStruct::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::ActionStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActionList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActionList |
| namespace EndpointLists { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::Actions::Structs::EndpointListStruct::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::EndpointListStruct::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::EndpointListStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::EndpointLists::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace EndpointLists |
| namespace SetupURL { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SetupURL::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 512; } |
| }; |
| } // namespace SetupURL |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::ActionList::TypeInfo::DecodableType actionList; |
| Attributes::EndpointLists::TypeInfo::DecodableType endpointLists; |
| Attributes::SetupURL::TypeInfo::DecodableType setupURL; |
| 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 Events { |
| namespace StateChanged { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| kNewState = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StateChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| uint32_t invokeID = static_cast<uint32_t>(0); |
| ActionStateEnum newState = static_cast<ActionStateEnum>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StateChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| uint32_t invokeID = static_cast<uint32_t>(0); |
| ActionStateEnum newState = static_cast<ActionStateEnum>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace StateChanged |
| namespace ActionFailed { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kActionID = 0, |
| kInvokeID = 1, |
| kNewState = 2, |
| kError = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ActionFailed::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| uint32_t invokeID = static_cast<uint32_t>(0); |
| ActionStateEnum newState = static_cast<ActionStateEnum>(0); |
| ActionErrorEnum error = static_cast<ActionErrorEnum>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ActionFailed::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Actions::Id; } |
| |
| uint16_t actionID = static_cast<uint16_t>(0); |
| uint32_t invokeID = static_cast<uint32_t>(0); |
| ActionStateEnum newState = static_cast<ActionStateEnum>(0); |
| ActionErrorEnum error = static_cast<ActionErrorEnum>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace ActionFailed |
| } // namespace Events |
| } // namespace Actions |
| namespace Basic { |
| namespace Structs { |
| namespace CapabilityMinimaStruct { |
| enum class Fields |
| { |
| kCaseSessionsPerFabric = 0, |
| kSubscriptionsPerFabric = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint16_t caseSessionsPerFabric = static_cast<uint16_t>(0); |
| uint16_t subscriptionsPerFabric = static_cast<uint16_t>(0); |
| |
| 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 CapabilityMinimaStruct |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace MfgSpecificPing { |
| struct Type; |
| struct DecodableType; |
| } // namespace MfgSpecificPing |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace MfgSpecificPing { |
| 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::MfgSpecificPing::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::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::MfgSpecificPing::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace MfgSpecificPing |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace DataModelRevision { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::DataModelRevision::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace DataModelRevision |
| namespace VendorName { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::VendorName::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace VendorName |
| namespace VendorID { |
| struct TypeInfo |
| { |
| using Type = chip::VendorId; |
| using DecodableType = chip::VendorId; |
| using DecodableArgType = chip::VendorId; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::VendorID::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace VendorID |
| namespace ProductName { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ProductName::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace ProductName |
| namespace ProductID { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ProductID::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ProductID |
| namespace NodeLabel { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NodeLabel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace NodeLabel |
| namespace Location { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Location::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 2; } |
| }; |
| } // namespace Location |
| namespace HardwareVersion { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersion::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace HardwareVersion |
| namespace HardwareVersionString { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersionString::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 64; } |
| }; |
| } // namespace HardwareVersionString |
| namespace SoftwareVersion { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersion::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SoftwareVersion |
| namespace SoftwareVersionString { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersionString::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 64; } |
| }; |
| } // namespace SoftwareVersionString |
| namespace ManufacturingDate { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ManufacturingDate::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 16; } |
| }; |
| } // namespace ManufacturingDate |
| namespace PartNumber { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PartNumber::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace PartNumber |
| namespace ProductURL { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ProductURL::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 256; } |
| }; |
| } // namespace ProductURL |
| namespace ProductLabel { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ProductLabel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 64; } |
| }; |
| } // namespace ProductLabel |
| namespace SerialNumber { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SerialNumber::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace SerialNumber |
| namespace LocalConfigDisabled { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LocalConfigDisabled::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LocalConfigDisabled |
| namespace Reachable { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Reachable::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Reachable |
| namespace UniqueID { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::UniqueID::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace UniqueID |
| namespace CapabilityMinima { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::Basic::Structs::CapabilityMinimaStruct::Type; |
| using DecodableType = chip::app::Clusters::Basic::Structs::CapabilityMinimaStruct::DecodableType; |
| using DecodableArgType = const chip::app::Clusters::Basic::Structs::CapabilityMinimaStruct::DecodableType &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CapabilityMinima::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CapabilityMinima |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::DataModelRevision::TypeInfo::DecodableType dataModelRevision = static_cast<uint16_t>(0); |
| Attributes::VendorName::TypeInfo::DecodableType vendorName; |
| Attributes::VendorID::TypeInfo::DecodableType vendorID = static_cast<chip::VendorId>(0); |
| Attributes::ProductName::TypeInfo::DecodableType productName; |
| Attributes::ProductID::TypeInfo::DecodableType productID = static_cast<uint16_t>(0); |
| Attributes::NodeLabel::TypeInfo::DecodableType nodeLabel; |
| Attributes::Location::TypeInfo::DecodableType location; |
| Attributes::HardwareVersion::TypeInfo::DecodableType hardwareVersion = static_cast<uint16_t>(0); |
| Attributes::HardwareVersionString::TypeInfo::DecodableType hardwareVersionString; |
| Attributes::SoftwareVersion::TypeInfo::DecodableType softwareVersion = static_cast<uint32_t>(0); |
| Attributes::SoftwareVersionString::TypeInfo::DecodableType softwareVersionString; |
| Attributes::ManufacturingDate::TypeInfo::DecodableType manufacturingDate; |
| Attributes::PartNumber::TypeInfo::DecodableType partNumber; |
| Attributes::ProductURL::TypeInfo::DecodableType productURL; |
| Attributes::ProductLabel::TypeInfo::DecodableType productLabel; |
| Attributes::SerialNumber::TypeInfo::DecodableType serialNumber; |
| Attributes::LocalConfigDisabled::TypeInfo::DecodableType localConfigDisabled = static_cast<bool>(0); |
| Attributes::Reachable::TypeInfo::DecodableType reachable = static_cast<bool>(0); |
| Attributes::UniqueID::TypeInfo::DecodableType uniqueID; |
| Attributes::CapabilityMinima::TypeInfo::DecodableType capabilityMinima; |
| 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 Events { |
| namespace StartUp { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical; |
| |
| enum class Fields |
| { |
| kSoftwareVersion = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StartUp::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StartUp::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace StartUp |
| namespace ShutDown { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical; |
| |
| enum class Fields |
| { |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ShutDown::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ShutDown::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace ShutDown |
| namespace Leave { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kFabricIndex = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::Leave::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::Leave::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace Leave |
| namespace ReachableChanged { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kReachableNewValue = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ReachableChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| bool reachableNewValue = static_cast<bool>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ReachableChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } |
| |
| bool reachableNewValue = static_cast<bool>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace ReachableChanged |
| } // namespace Events |
| } // namespace Basic |
| namespace OtaSoftwareUpdateProvider { |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace QueryImage { |
| struct Type; |
| struct DecodableType; |
| } // namespace QueryImage |
| |
| namespace QueryImageResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace QueryImageResponse |
| |
| namespace ApplyUpdateRequest { |
| struct Type; |
| struct DecodableType; |
| } // namespace ApplyUpdateRequest |
| |
| namespace ApplyUpdateResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace ApplyUpdateResponse |
| |
| namespace NotifyUpdateApplied { |
| struct Type; |
| struct DecodableType; |
| } // namespace NotifyUpdateApplied |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace QueryImage { |
| enum class Fields |
| { |
| kVendorId = 0, |
| kProductId = 1, |
| kSoftwareVersion = 2, |
| kProtocolsSupported = 3, |
| kHardwareVersion = 4, |
| kLocation = 5, |
| kRequestorCanConsent = 6, |
| kMetadataForProvider = 7, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::QueryImage::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| chip::VendorId vendorId = static_cast<chip::VendorId>(0); |
| uint16_t productId = static_cast<uint16_t>(0); |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| DataModel::List<const OTADownloadProtocol> protocolsSupported; |
| Optional<uint16_t> hardwareVersion; |
| Optional<chip::CharSpan> location; |
| Optional<bool> requestorCanConsent; |
| Optional<chip::ByteSpan> metadataForProvider; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::OtaSoftwareUpdateProvider::Commands::QueryImageResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::QueryImage::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| chip::VendorId vendorId = static_cast<chip::VendorId>(0); |
| uint16_t productId = static_cast<uint16_t>(0); |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| DataModel::DecodableList<OTADownloadProtocol> protocolsSupported; |
| Optional<uint16_t> hardwareVersion; |
| Optional<chip::CharSpan> location; |
| Optional<bool> requestorCanConsent; |
| Optional<chip::ByteSpan> metadataForProvider; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace QueryImage |
| namespace QueryImageResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kDelayedActionTime = 1, |
| kImageURI = 2, |
| kSoftwareVersion = 3, |
| kSoftwareVersionString = 4, |
| kUpdateToken = 5, |
| kUserConsentNeeded = 6, |
| kMetadataForRequestor = 7, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::QueryImageResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| OTAQueryStatus status = static_cast<OTAQueryStatus>(0); |
| Optional<uint32_t> delayedActionTime; |
| Optional<chip::CharSpan> imageURI; |
| Optional<uint32_t> softwareVersion; |
| Optional<chip::CharSpan> softwareVersionString; |
| Optional<chip::ByteSpan> updateToken; |
| Optional<bool> userConsentNeeded; |
| Optional<chip::ByteSpan> metadataForRequestor; |
| |
| 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::QueryImageResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| OTAQueryStatus status = static_cast<OTAQueryStatus>(0); |
| Optional<uint32_t> delayedActionTime; |
| Optional<chip::CharSpan> imageURI; |
| Optional<uint32_t> softwareVersion; |
| Optional<chip::CharSpan> softwareVersionString; |
| Optional<chip::ByteSpan> updateToken; |
| Optional<bool> userConsentNeeded; |
| Optional<chip::ByteSpan> metadataForRequestor; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace QueryImageResponse |
| namespace ApplyUpdateRequest { |
| enum class Fields |
| { |
| kUpdateToken = 0, |
| kNewVersion = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ApplyUpdateRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| chip::ByteSpan updateToken; |
| uint32_t newVersion = static_cast<uint32_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ApplyUpdateRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| chip::ByteSpan updateToken; |
| uint32_t newVersion = static_cast<uint32_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ApplyUpdateRequest |
| namespace ApplyUpdateResponse { |
| enum class Fields |
| { |
| kAction = 0, |
| kDelayedActionTime = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ApplyUpdateResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| OTAApplyUpdateAction action = static_cast<OTAApplyUpdateAction>(0); |
| uint32_t delayedActionTime = static_cast<uint32_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::ApplyUpdateResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| OTAApplyUpdateAction action = static_cast<OTAApplyUpdateAction>(0); |
| uint32_t delayedActionTime = static_cast<uint32_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ApplyUpdateResponse |
| namespace NotifyUpdateApplied { |
| enum class Fields |
| { |
| kUpdateToken = 0, |
| kSoftwareVersion = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::NotifyUpdateApplied::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| chip::ByteSpan updateToken; |
| uint32_t softwareVersion = static_cast<uint32_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::NotifyUpdateApplied::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| chip::ByteSpan updateToken; |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace NotifyUpdateApplied |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| 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 OtaSoftwareUpdateProvider |
| namespace OtaSoftwareUpdateRequestor { |
| namespace Structs { |
| namespace ProviderLocation { |
| enum class Fields |
| { |
| kProviderNodeID = 1, |
| kEndpoint = 2, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::NodeId providerNodeID = static_cast<chip::NodeId>(0); |
| chip::EndpointId endpoint = static_cast<chip::EndpointId>(0); |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| |
| CHIP_ERROR EncodeForWrite(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| CHIP_ERROR EncodeForRead(TLV::TLVWriter & writer, TLV::Tag tag, FabricIndex accessingFabricIndex) const; |
| |
| private: |
| CHIP_ERROR DoEncode(TLV::TLVWriter & writer, TLV::Tag tag, const Optional<FabricIndex> & accessingFabricIndex) const; |
| }; |
| |
| using DecodableType = Type; |
| |
| } // namespace ProviderLocation |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace AnnounceOtaProvider { |
| struct Type; |
| struct DecodableType; |
| } // namespace AnnounceOtaProvider |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace AnnounceOtaProvider { |
| enum class Fields |
| { |
| kProviderNodeId = 0, |
| kVendorId = 1, |
| kAnnouncementReason = 2, |
| kMetadataForNode = 3, |
| kEndpoint = 4, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AnnounceOtaProvider::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| |
| chip::NodeId providerNodeId = static_cast<chip::NodeId>(0); |
| chip::VendorId vendorId = static_cast<chip::VendorId>(0); |
| OTAAnnouncementReason announcementReason = static_cast<OTAAnnouncementReason>(0); |
| Optional<chip::ByteSpan> metadataForNode; |
| chip::EndpointId endpoint = static_cast<chip::EndpointId>(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::AnnounceOtaProvider::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| |
| chip::NodeId providerNodeId = static_cast<chip::NodeId>(0); |
| chip::VendorId vendorId = static_cast<chip::VendorId>(0); |
| OTAAnnouncementReason announcementReason = static_cast<OTAAnnouncementReason>(0); |
| Optional<chip::ByteSpan> metadataForNode; |
| chip::EndpointId endpoint = static_cast<chip::EndpointId>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AnnounceOtaProvider |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace DefaultOtaProviders { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type>; |
| using DecodableType = chip::app::DataModel::DecodableList< |
| chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList< |
| chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::DefaultOtaProviders::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace DefaultOtaProviders |
| namespace UpdatePossible { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::UpdatePossible::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace UpdatePossible |
| namespace UpdateState { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum; |
| using DecodableType = chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum; |
| using DecodableArgType = chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::UpdateState::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace UpdateState |
| namespace UpdateStateProgress { |
| 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::OtaSoftwareUpdateRequestor::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::UpdateStateProgress::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace UpdateStateProgress |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::DefaultOtaProviders::TypeInfo::DecodableType defaultOtaProviders; |
| Attributes::UpdatePossible::TypeInfo::DecodableType updatePossible = static_cast<bool>(0); |
| Attributes::UpdateState::TypeInfo::DecodableType updateState = |
| static_cast<chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum>(0); |
| Attributes::UpdateStateProgress::TypeInfo::DecodableType updateStateProgress; |
| 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 Events { |
| namespace StateTransition { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kPreviousState = 0, |
| kNewState = 1, |
| kReason = 2, |
| kTargetSoftwareVersion = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StateTransition::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| OTAUpdateStateEnum previousState = static_cast<OTAUpdateStateEnum>(0); |
| OTAUpdateStateEnum newState = static_cast<OTAUpdateStateEnum>(0); |
| OTAChangeReasonEnum reason = static_cast<OTAChangeReasonEnum>(0); |
| DataModel::Nullable<uint32_t> targetSoftwareVersion; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StateTransition::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| |
| OTAUpdateStateEnum previousState = static_cast<OTAUpdateStateEnum>(0); |
| OTAUpdateStateEnum newState = static_cast<OTAUpdateStateEnum>(0); |
| OTAChangeReasonEnum reason = static_cast<OTAChangeReasonEnum>(0); |
| DataModel::Nullable<uint32_t> targetSoftwareVersion; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace StateTransition |
| namespace VersionApplied { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical; |
| |
| enum class Fields |
| { |
| kSoftwareVersion = 0, |
| kProductID = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::VersionApplied::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| uint16_t productID = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::VersionApplied::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| uint16_t productID = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace VersionApplied |
| namespace DownloadError { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kSoftwareVersion = 0, |
| kBytesDownloaded = 1, |
| kProgressPercent = 2, |
| kPlatformCode = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::DownloadError::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| uint64_t bytesDownloaded = static_cast<uint64_t>(0); |
| DataModel::Nullable<uint8_t> progressPercent; |
| DataModel::Nullable<int64_t> platformCode; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::DownloadError::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } |
| |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| uint64_t bytesDownloaded = static_cast<uint64_t>(0); |
| DataModel::Nullable<uint8_t> progressPercent; |
| DataModel::Nullable<int64_t> platformCode; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace DownloadError |
| } // namespace Events |
| } // namespace OtaSoftwareUpdateRequestor |
| namespace LocalizationConfiguration { |
| |
| namespace Attributes { |
| |
| namespace ActiveLocale { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveLocale::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 35; } |
| }; |
| } // namespace ActiveLocale |
| namespace SupportedLocales { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::CharSpan>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::CharSpan>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<chip::CharSpan> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SupportedLocales::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SupportedLocales |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::ActiveLocale::TypeInfo::DecodableType activeLocale; |
| Attributes::SupportedLocales::TypeInfo::DecodableType supportedLocales; |
| 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 LocalizationConfiguration |
| namespace TimeFormatLocalization { |
| |
| namespace Attributes { |
| |
| namespace HourFormat { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::TimeFormatLocalization::HourFormat; |
| using DecodableType = chip::app::Clusters::TimeFormatLocalization::HourFormat; |
| using DecodableArgType = chip::app::Clusters::TimeFormatLocalization::HourFormat; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::HourFormat::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace HourFormat |
| namespace ActiveCalendarType { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::TimeFormatLocalization::CalendarType; |
| using DecodableType = chip::app::Clusters::TimeFormatLocalization::CalendarType; |
| using DecodableArgType = chip::app::Clusters::TimeFormatLocalization::CalendarType; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveCalendarType::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActiveCalendarType |
| namespace SupportedCalendarTypes { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::TimeFormatLocalization::CalendarType>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::TimeFormatLocalization::CalendarType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::TimeFormatLocalization::CalendarType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SupportedCalendarTypes::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SupportedCalendarTypes |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeFormatLocalization::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::HourFormat::TypeInfo::DecodableType hourFormat = |
| static_cast<chip::app::Clusters::TimeFormatLocalization::HourFormat>(0); |
| Attributes::ActiveCalendarType::TypeInfo::DecodableType activeCalendarType = |
| static_cast<chip::app::Clusters::TimeFormatLocalization::CalendarType>(0); |
| Attributes::SupportedCalendarTypes::TypeInfo::DecodableType supportedCalendarTypes; |
| 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 TimeFormatLocalization |
| namespace UnitLocalization { |
| |
| namespace Attributes { |
| |
| namespace TemperatureUnit { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::UnitLocalization::TempUnit; |
| using DecodableType = chip::app::Clusters::UnitLocalization::TempUnit; |
| using DecodableArgType = chip::app::Clusters::UnitLocalization::TempUnit; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TemperatureUnit::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TemperatureUnit |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UnitLocalization::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::TemperatureUnit::TypeInfo::DecodableType temperatureUnit = |
| static_cast<chip::app::Clusters::UnitLocalization::TempUnit>(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 UnitLocalization |
| namespace PowerSourceConfiguration { |
| |
| namespace Attributes { |
| |
| namespace Sources { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const uint8_t>; |
| using DecodableType = chip::app::DataModel::DecodableList<uint8_t>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<uint8_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Sources::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Sources |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::Sources::TypeInfo::DecodableType sources; |
| 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 PowerSourceConfiguration |
| namespace PowerSource { |
| namespace Structs { |
| namespace BatChargeFaultChangeType { |
| enum class Fields |
| { |
| kCurrent = 0, |
| kPrevious = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| DataModel::List<const BatChargeFault> current; |
| DataModel::List<const BatChargeFault> previous; |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| DataModel::DecodableList<BatChargeFault> current; |
| DataModel::DecodableList<BatChargeFault> previous; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| }; |
| |
| } // namespace BatChargeFaultChangeType |
| namespace BatFaultChangeType { |
| enum class Fields |
| { |
| kCurrent = 0, |
| kPrevious = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| DataModel::List<const BatFault> current; |
| DataModel::List<const BatFault> previous; |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| DataModel::DecodableList<BatFault> current; |
| DataModel::DecodableList<BatFault> previous; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| }; |
| |
| } // namespace BatFaultChangeType |
| namespace WiredFaultChangeType { |
| enum class Fields |
| { |
| kCurrent = 0, |
| kPrevious = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| DataModel::List<const WiredFault> current; |
| DataModel::List<const WiredFault> previous; |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| DataModel::DecodableList<WiredFault> current; |
| DataModel::DecodableList<WiredFault> previous; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| }; |
| |
| } // namespace WiredFaultChangeType |
| } // namespace Structs |
| |
| namespace Attributes { |
| |
| namespace Status { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::PowerSource::PowerSourceStatus; |
| using DecodableType = chip::app::Clusters::PowerSource::PowerSourceStatus; |
| using DecodableArgType = chip::app::Clusters::PowerSource::PowerSourceStatus; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Status::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Status |
| namespace Order { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Order::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Order |
| namespace Description { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Description::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 60; } |
| }; |
| } // namespace Description |
| namespace WiredAssessedInputVoltage { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedInputVoltage::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace WiredAssessedInputVoltage |
| namespace WiredAssessedInputFrequency { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedInputFrequency::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace WiredAssessedInputFrequency |
| namespace WiredCurrentType { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::PowerSource::WiredCurrentType; |
| using DecodableType = chip::app::Clusters::PowerSource::WiredCurrentType; |
| using DecodableArgType = chip::app::Clusters::PowerSource::WiredCurrentType; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::WiredCurrentType::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace WiredCurrentType |
| namespace WiredAssessedCurrent { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::WiredAssessedCurrent::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace WiredAssessedCurrent |
| namespace WiredNominalVoltage { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::WiredNominalVoltage::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace WiredNominalVoltage |
| namespace WiredMaximumCurrent { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::WiredMaximumCurrent::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace WiredMaximumCurrent |
| namespace WiredPresent { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::WiredPresent::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace WiredPresent |
| namespace ActiveWiredFaults { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::PowerSource::WiredFault>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::WiredFault>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::WiredFault> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveWiredFaults::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActiveWiredFaults |
| namespace BatVoltage { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatVoltage::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatVoltage |
| namespace BatPercentRemaining { |
| 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::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatPercentRemaining::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatPercentRemaining |
| namespace BatTimeRemaining { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatTimeRemaining::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatTimeRemaining |
| namespace BatChargeLevel { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::PowerSource::BatChargeLevel; |
| using DecodableType = chip::app::Clusters::PowerSource::BatChargeLevel; |
| using DecodableArgType = chip::app::Clusters::PowerSource::BatChargeLevel; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatChargeLevel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatChargeLevel |
| namespace BatReplacementNeeded { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatReplacementNeeded::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatReplacementNeeded |
| namespace BatReplaceability { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::PowerSource::BatReplaceability; |
| using DecodableType = chip::app::Clusters::PowerSource::BatReplaceability; |
| using DecodableArgType = chip::app::Clusters::PowerSource::BatReplaceability; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatReplaceability::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatReplaceability |
| namespace BatPresent { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatPresent::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatPresent |
| namespace ActiveBatFaults { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::PowerSource::BatFault>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatFault>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatFault> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatFaults::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActiveBatFaults |
| namespace BatReplacementDescription { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatReplacementDescription::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 60; } |
| }; |
| } // namespace BatReplacementDescription |
| namespace BatCommonDesignation { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatCommonDesignation::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatCommonDesignation |
| namespace BatANSIDesignation { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatANSIDesignation::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 20; } |
| }; |
| } // namespace BatANSIDesignation |
| namespace BatIECDesignation { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatIECDesignation::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 20; } |
| }; |
| } // namespace BatIECDesignation |
| namespace BatApprovedChemistry { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatApprovedChemistry::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatApprovedChemistry |
| namespace BatCapacity { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatCapacity::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatCapacity |
| namespace BatQuantity { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatQuantity::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatQuantity |
| namespace BatChargeState { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::PowerSource::BatChargeState; |
| using DecodableType = chip::app::Clusters::PowerSource::BatChargeState; |
| using DecodableArgType = chip::app::Clusters::PowerSource::BatChargeState; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatChargeState::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatChargeState |
| namespace BatTimeToFullCharge { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatTimeToFullCharge::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatTimeToFullCharge |
| namespace BatFunctionalWhileCharging { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatFunctionalWhileCharging::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatFunctionalWhileCharging |
| namespace BatChargingCurrent { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BatChargingCurrent::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BatChargingCurrent |
| namespace ActiveBatChargeFaults { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::PowerSource::BatChargeFault>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatChargeFault>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatChargeFault> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveBatChargeFaults::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActiveBatChargeFaults |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::Status::TypeInfo::DecodableType status = static_cast<chip::app::Clusters::PowerSource::PowerSourceStatus>(0); |
| Attributes::Order::TypeInfo::DecodableType order = static_cast<uint8_t>(0); |
| Attributes::Description::TypeInfo::DecodableType description; |
| Attributes::WiredAssessedInputVoltage::TypeInfo::DecodableType wiredAssessedInputVoltage; |
| Attributes::WiredAssessedInputFrequency::TypeInfo::DecodableType wiredAssessedInputFrequency; |
| Attributes::WiredCurrentType::TypeInfo::DecodableType wiredCurrentType = |
| static_cast<chip::app::Clusters::PowerSource::WiredCurrentType>(0); |
| Attributes::WiredAssessedCurrent::TypeInfo::DecodableType wiredAssessedCurrent; |
| Attributes::WiredNominalVoltage::TypeInfo::DecodableType wiredNominalVoltage = static_cast<uint32_t>(0); |
| Attributes::WiredMaximumCurrent::TypeInfo::DecodableType wiredMaximumCurrent = static_cast<uint32_t>(0); |
| Attributes::WiredPresent::TypeInfo::DecodableType wiredPresent = static_cast<bool>(0); |
| Attributes::ActiveWiredFaults::TypeInfo::DecodableType activeWiredFaults; |
| Attributes::BatVoltage::TypeInfo::DecodableType batVoltage; |
| Attributes::BatPercentRemaining::TypeInfo::DecodableType batPercentRemaining; |
| Attributes::BatTimeRemaining::TypeInfo::DecodableType batTimeRemaining; |
| Attributes::BatChargeLevel::TypeInfo::DecodableType batChargeLevel = |
| static_cast<chip::app::Clusters::PowerSource::BatChargeLevel>(0); |
| Attributes::BatReplacementNeeded::TypeInfo::DecodableType batReplacementNeeded = static_cast<bool>(0); |
| Attributes::BatReplaceability::TypeInfo::DecodableType batReplaceability = |
| static_cast<chip::app::Clusters::PowerSource::BatReplaceability>(0); |
| Attributes::BatPresent::TypeInfo::DecodableType batPresent = static_cast<bool>(0); |
| Attributes::ActiveBatFaults::TypeInfo::DecodableType activeBatFaults; |
| Attributes::BatReplacementDescription::TypeInfo::DecodableType batReplacementDescription; |
| Attributes::BatCommonDesignation::TypeInfo::DecodableType batCommonDesignation = static_cast<uint32_t>(0); |
| Attributes::BatANSIDesignation::TypeInfo::DecodableType batANSIDesignation; |
| Attributes::BatIECDesignation::TypeInfo::DecodableType batIECDesignation; |
| Attributes::BatApprovedChemistry::TypeInfo::DecodableType batApprovedChemistry = static_cast<uint32_t>(0); |
| Attributes::BatCapacity::TypeInfo::DecodableType batCapacity = static_cast<uint32_t>(0); |
| Attributes::BatQuantity::TypeInfo::DecodableType batQuantity = static_cast<uint8_t>(0); |
| Attributes::BatChargeState::TypeInfo::DecodableType batChargeState = |
| static_cast<chip::app::Clusters::PowerSource::BatChargeState>(0); |
| Attributes::BatTimeToFullCharge::TypeInfo::DecodableType batTimeToFullCharge; |
| Attributes::BatFunctionalWhileCharging::TypeInfo::DecodableType batFunctionalWhileCharging = static_cast<bool>(0); |
| Attributes::BatChargingCurrent::TypeInfo::DecodableType batChargingCurrent; |
| Attributes::ActiveBatChargeFaults::TypeInfo::DecodableType activeBatChargeFaults; |
| 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 PowerSource |
| namespace GeneralCommissioning { |
| namespace Structs { |
| namespace BasicCommissioningInfo { |
| enum class Fields |
| { |
| kFailSafeExpiryLengthSeconds = 0, |
| kMaxCumulativeFailsafeSeconds = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint16_t failSafeExpiryLengthSeconds = static_cast<uint16_t>(0); |
| uint16_t maxCumulativeFailsafeSeconds = static_cast<uint16_t>(0); |
| |
| 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 BasicCommissioningInfo |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace ArmFailSafe { |
| struct Type; |
| struct DecodableType; |
| } // namespace ArmFailSafe |
| |
| namespace ArmFailSafeResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace ArmFailSafeResponse |
| |
| namespace SetRegulatoryConfig { |
| struct Type; |
| struct DecodableType; |
| } // namespace SetRegulatoryConfig |
| |
| namespace SetRegulatoryConfigResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace SetRegulatoryConfigResponse |
| |
| namespace CommissioningComplete { |
| struct Type; |
| struct DecodableType; |
| } // namespace CommissioningComplete |
| |
| namespace CommissioningCompleteResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace CommissioningCompleteResponse |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace ArmFailSafe { |
| enum class Fields |
| { |
| kExpiryLengthSeconds = 0, |
| kBreadcrumb = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ArmFailSafe::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| uint16_t expiryLengthSeconds = static_cast<uint16_t>(0); |
| uint64_t breadcrumb = static_cast<uint64_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ArmFailSafe::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| uint16_t expiryLengthSeconds = static_cast<uint16_t>(0); |
| uint64_t breadcrumb = static_cast<uint64_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ArmFailSafe |
| namespace ArmFailSafeResponse { |
| enum class Fields |
| { |
| kErrorCode = 0, |
| kDebugText = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ArmFailSafeResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| CommissioningError errorCode = static_cast<CommissioningError>(0); |
| chip::CharSpan debugText; |
| |
| 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::ArmFailSafeResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| CommissioningError errorCode = static_cast<CommissioningError>(0); |
| chip::CharSpan debugText; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ArmFailSafeResponse |
| namespace SetRegulatoryConfig { |
| enum class Fields |
| { |
| kNewRegulatoryConfig = 0, |
| kCountryCode = 1, |
| kBreadcrumb = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::SetRegulatoryConfig::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| RegulatoryLocationType newRegulatoryConfig = static_cast<RegulatoryLocationType>(0); |
| chip::CharSpan countryCode; |
| uint64_t breadcrumb = static_cast<uint64_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::GeneralCommissioning::Commands::SetRegulatoryConfigResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::SetRegulatoryConfig::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| RegulatoryLocationType newRegulatoryConfig = static_cast<RegulatoryLocationType>(0); |
| chip::CharSpan countryCode; |
| uint64_t breadcrumb = static_cast<uint64_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace SetRegulatoryConfig |
| namespace SetRegulatoryConfigResponse { |
| enum class Fields |
| { |
| kErrorCode = 0, |
| kDebugText = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::SetRegulatoryConfigResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| CommissioningError errorCode = static_cast<CommissioningError>(0); |
| chip::CharSpan debugText; |
| |
| 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::SetRegulatoryConfigResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| CommissioningError errorCode = static_cast<CommissioningError>(0); |
| chip::CharSpan debugText; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace SetRegulatoryConfigResponse |
| namespace CommissioningComplete { |
| 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::CommissioningComplete::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::GeneralCommissioning::Commands::CommissioningCompleteResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::CommissioningComplete::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace CommissioningComplete |
| namespace CommissioningCompleteResponse { |
| enum class Fields |
| { |
| kErrorCode = 0, |
| kDebugText = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::CommissioningCompleteResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| CommissioningError errorCode = static_cast<CommissioningError>(0); |
| chip::CharSpan debugText; |
| |
| 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::CommissioningCompleteResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| CommissioningError errorCode = static_cast<CommissioningError>(0); |
| chip::CharSpan debugText; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace CommissioningCompleteResponse |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace Breadcrumb { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Breadcrumb::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Breadcrumb |
| namespace BasicCommissioningInfo { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::Type; |
| using DecodableType = chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::DecodableType; |
| using DecodableArgType = const chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::DecodableType &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BasicCommissioningInfo::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BasicCommissioningInfo |
| namespace RegulatoryConfig { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType; |
| using DecodableType = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType; |
| using DecodableArgType = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RegulatoryConfig::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RegulatoryConfig |
| namespace LocationCapability { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType; |
| using DecodableType = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType; |
| using DecodableArgType = chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LocationCapability::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LocationCapability |
| namespace SupportsConcurrentConnection { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SupportsConcurrentConnection::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SupportsConcurrentConnection |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::Breadcrumb::TypeInfo::DecodableType breadcrumb = static_cast<uint64_t>(0); |
| Attributes::BasicCommissioningInfo::TypeInfo::DecodableType basicCommissioningInfo; |
| Attributes::RegulatoryConfig::TypeInfo::DecodableType regulatoryConfig = |
| static_cast<chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType>(0); |
| Attributes::LocationCapability::TypeInfo::DecodableType locationCapability = |
| static_cast<chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType>(0); |
| Attributes::SupportsConcurrentConnection::TypeInfo::DecodableType supportsConcurrentConnection = static_cast<bool>(0); |
| Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList; |
| Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList; |
| Attributes::AttributeList::TypeInfo::DecodableType attributeList; |
| Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0); |
| Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0); |
| }; |
| }; |
| } // namespace Attributes |
| } // namespace GeneralCommissioning |
| namespace NetworkCommissioning { |
| namespace Structs { |
| namespace NetworkInfo { |
| enum class Fields |
| { |
| kNetworkID = 0, |
| kConnected = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::ByteSpan networkID; |
| bool connected = static_cast<bool>(0); |
| |
| 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 NetworkInfo |
| namespace ThreadInterfaceScanResult { |
| enum class Fields |
| { |
| kPanId = 0, |
| kExtendedPanId = 1, |
| kNetworkName = 2, |
| kChannel = 3, |
| kVersion = 4, |
| kExtendedAddress = 5, |
| kRssi = 6, |
| kLqi = 7, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint16_t panId = static_cast<uint16_t>(0); |
| uint64_t extendedPanId = static_cast<uint64_t>(0); |
| chip::CharSpan networkName; |
| uint16_t channel = static_cast<uint16_t>(0); |
| uint8_t version = static_cast<uint8_t>(0); |
| chip::ByteSpan extendedAddress; |
| int8_t rssi = static_cast<int8_t>(0); |
| uint8_t lqi = static_cast<uint8_t>(0); |
| |
| 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 ThreadInterfaceScanResult |
| namespace WiFiInterfaceScanResult { |
| enum class Fields |
| { |
| kSecurity = 0, |
| kSsid = 1, |
| kBssid = 2, |
| kChannel = 3, |
| kWiFiBand = 4, |
| kRssi = 5, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::BitMask<WiFiSecurity> security = static_cast<chip::BitMask<WiFiSecurity>>(0); |
| chip::ByteSpan ssid; |
| chip::ByteSpan bssid; |
| uint16_t channel = static_cast<uint16_t>(0); |
| WiFiBand wiFiBand = static_cast<WiFiBand>(0); |
| int8_t rssi = static_cast<int8_t>(0); |
| |
| 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 WiFiInterfaceScanResult |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace ScanNetworks { |
| struct Type; |
| struct DecodableType; |
| } // namespace ScanNetworks |
| |
| namespace ScanNetworksResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace ScanNetworksResponse |
| |
| namespace AddOrUpdateWiFiNetwork { |
| struct Type; |
| struct DecodableType; |
| } // namespace AddOrUpdateWiFiNetwork |
| |
| namespace AddOrUpdateThreadNetwork { |
| struct Type; |
| struct DecodableType; |
| } // namespace AddOrUpdateThreadNetwork |
| |
| namespace RemoveNetwork { |
| struct Type; |
| struct DecodableType; |
| } // namespace RemoveNetwork |
| |
| namespace NetworkConfigResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace NetworkConfigResponse |
| |
| namespace ConnectNetwork { |
| struct Type; |
| struct DecodableType; |
| } // namespace ConnectNetwork |
| |
| namespace ConnectNetworkResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace ConnectNetworkResponse |
| |
| namespace ReorderNetwork { |
| struct Type; |
| struct DecodableType; |
| } // namespace ReorderNetwork |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace ScanNetworks { |
| enum class Fields |
| { |
| kSsid = 0, |
| kBreadcrumb = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ScanNetworks::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| Optional<DataModel::Nullable<chip::ByteSpan>> ssid; |
| Optional<uint64_t> breadcrumb; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::NetworkCommissioning::Commands::ScanNetworksResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ScanNetworks::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| Optional<DataModel::Nullable<chip::ByteSpan>> ssid; |
| Optional<uint64_t> breadcrumb; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ScanNetworks |
| namespace ScanNetworksResponse { |
| enum class Fields |
| { |
| kNetworkingStatus = 0, |
| kDebugText = 1, |
| kWiFiScanResults = 2, |
| kThreadScanResults = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ScanNetworksResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| NetworkCommissioningStatus networkingStatus = static_cast<NetworkCommissioningStatus>(0); |
| Optional<chip::CharSpan> debugText; |
| Optional<DataModel::List<const Structs::WiFiInterfaceScanResult::Type>> wiFiScanResults; |
| Optional<DataModel::List<const Structs::ThreadInterfaceScanResult::Type>> threadScanResults; |
| |
| 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::ScanNetworksResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| NetworkCommissioningStatus networkingStatus = static_cast<NetworkCommissioningStatus>(0); |
| Optional<chip::CharSpan> debugText; |
| Optional<DataModel::DecodableList<Structs::WiFiInterfaceScanResult::DecodableType>> wiFiScanResults; |
| Optional<DataModel::DecodableList<Structs::ThreadInterfaceScanResult::DecodableType>> threadScanResults; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ScanNetworksResponse |
| namespace AddOrUpdateWiFiNetwork { |
| enum class Fields |
| { |
| kSsid = 0, |
| kCredentials = 1, |
| kBreadcrumb = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AddOrUpdateWiFiNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan ssid; |
| chip::ByteSpan credentials; |
| Optional<uint64_t> breadcrumb; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::AddOrUpdateWiFiNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan ssid; |
| chip::ByteSpan credentials; |
| Optional<uint64_t> breadcrumb; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AddOrUpdateWiFiNetwork |
| namespace AddOrUpdateThreadNetwork { |
| enum class Fields |
| { |
| kOperationalDataset = 0, |
| kBreadcrumb = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AddOrUpdateThreadNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan operationalDataset; |
| Optional<uint64_t> breadcrumb; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::AddOrUpdateThreadNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan operationalDataset; |
| Optional<uint64_t> breadcrumb; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AddOrUpdateThreadNetwork |
| namespace RemoveNetwork { |
| enum class Fields |
| { |
| kNetworkID = 0, |
| kBreadcrumb = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RemoveNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan networkID; |
| Optional<uint64_t> breadcrumb; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RemoveNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan networkID; |
| Optional<uint64_t> breadcrumb; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RemoveNetwork |
| namespace NetworkConfigResponse { |
| enum class Fields |
| { |
| kNetworkingStatus = 0, |
| kDebugText = 1, |
| kNetworkIndex = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::NetworkConfigResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| NetworkCommissioningStatus networkingStatus = static_cast<NetworkCommissioningStatus>(0); |
| Optional<chip::CharSpan> debugText; |
| Optional<uint8_t> networkIndex; |
| |
| 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::NetworkConfigResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| NetworkCommissioningStatus networkingStatus = static_cast<NetworkCommissioningStatus>(0); |
| Optional<chip::CharSpan> debugText; |
| Optional<uint8_t> networkIndex; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace NetworkConfigResponse |
| namespace ConnectNetwork { |
| enum class Fields |
| { |
| kNetworkID = 0, |
| kBreadcrumb = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ConnectNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan networkID; |
| Optional<uint64_t> breadcrumb; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::NetworkCommissioning::Commands::ConnectNetworkResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ConnectNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan networkID; |
| Optional<uint64_t> breadcrumb; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ConnectNetwork |
| namespace ConnectNetworkResponse { |
| enum class Fields |
| { |
| kNetworkingStatus = 0, |
| kDebugText = 1, |
| kErrorValue = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ConnectNetworkResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| NetworkCommissioningStatus networkingStatus = static_cast<NetworkCommissioningStatus>(0); |
| Optional<chip::CharSpan> debugText; |
| DataModel::Nullable<int32_t> errorValue; |
| |
| 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::ConnectNetworkResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| NetworkCommissioningStatus networkingStatus = static_cast<NetworkCommissioningStatus>(0); |
| Optional<chip::CharSpan> debugText; |
| DataModel::Nullable<int32_t> errorValue; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ConnectNetworkResponse |
| namespace ReorderNetwork { |
| enum class Fields |
| { |
| kNetworkID = 0, |
| kNetworkIndex = 1, |
| kBreadcrumb = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ReorderNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan networkID; |
| uint8_t networkIndex = static_cast<uint8_t>(0); |
| Optional<uint64_t> breadcrumb; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::ReorderNetwork::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| chip::ByteSpan networkID; |
| uint8_t networkIndex = static_cast<uint8_t>(0); |
| Optional<uint64_t> breadcrumb; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ReorderNetwork |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace MaxNetworks { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::MaxNetworks::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace MaxNetworks |
| namespace Networks { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfo::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfo::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfo::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Networks::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Networks |
| namespace ScanMaxTimeSeconds { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ScanMaxTimeSeconds::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ScanMaxTimeSeconds |
| namespace ConnectMaxTimeSeconds { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ConnectMaxTimeSeconds::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ConnectMaxTimeSeconds |
| namespace InterfaceEnabled { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::InterfaceEnabled::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace InterfaceEnabled |
| namespace LastNetworkingStatus { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatus>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatus>; |
| using DecodableArgType = |
| const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatus> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LastNetworkingStatus::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LastNetworkingStatus |
| namespace LastNetworkID { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::ByteSpan>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LastNetworkID::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace LastNetworkID |
| namespace LastConnectErrorValue { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<int32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<int32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<int32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LastConnectErrorValue::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LastConnectErrorValue |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::MaxNetworks::TypeInfo::DecodableType maxNetworks = static_cast<uint8_t>(0); |
| Attributes::Networks::TypeInfo::DecodableType networks; |
| Attributes::ScanMaxTimeSeconds::TypeInfo::DecodableType scanMaxTimeSeconds = static_cast<uint8_t>(0); |
| Attributes::ConnectMaxTimeSeconds::TypeInfo::DecodableType connectMaxTimeSeconds = static_cast<uint8_t>(0); |
| Attributes::InterfaceEnabled::TypeInfo::DecodableType interfaceEnabled = static_cast<bool>(0); |
| Attributes::LastNetworkingStatus::TypeInfo::DecodableType lastNetworkingStatus; |
| Attributes::LastNetworkID::TypeInfo::DecodableType lastNetworkID; |
| Attributes::LastConnectErrorValue::TypeInfo::DecodableType lastConnectErrorValue; |
| 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 NetworkCommissioning |
| namespace DiagnosticLogs { |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace RetrieveLogsRequest { |
| struct Type; |
| struct DecodableType; |
| } // namespace RetrieveLogsRequest |
| |
| namespace RetrieveLogsResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace RetrieveLogsResponse |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace RetrieveLogsRequest { |
| enum class Fields |
| { |
| kIntent = 0, |
| kRequestedProtocol = 1, |
| kTransferFileDesignator = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RetrieveLogsRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| |
| LogsIntent intent = static_cast<LogsIntent>(0); |
| LogsTransferProtocol requestedProtocol = static_cast<LogsTransferProtocol>(0); |
| chip::ByteSpan transferFileDesignator; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RetrieveLogsRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| |
| LogsIntent intent = static_cast<LogsIntent>(0); |
| LogsTransferProtocol requestedProtocol = static_cast<LogsTransferProtocol>(0); |
| chip::ByteSpan transferFileDesignator; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RetrieveLogsRequest |
| namespace RetrieveLogsResponse { |
| enum class Fields |
| { |
| kStatus = 0, |
| kContent = 1, |
| kTimeStamp = 2, |
| kTimeSinceBoot = 3, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RetrieveLogsResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| |
| LogsStatus status = static_cast<LogsStatus>(0); |
| chip::ByteSpan content; |
| uint32_t timeStamp = static_cast<uint32_t>(0); |
| uint32_t timeSinceBoot = static_cast<uint32_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::RetrieveLogsResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| |
| LogsStatus status = static_cast<LogsStatus>(0); |
| chip::ByteSpan content; |
| uint32_t timeStamp = static_cast<uint32_t>(0); |
| uint32_t timeSinceBoot = static_cast<uint32_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RetrieveLogsResponse |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| 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 DiagnosticLogs |
| namespace GeneralDiagnostics { |
| namespace Structs { |
| namespace NetworkInterfaceType { |
| enum class Fields |
| { |
| kName = 0, |
| kIsOperational = 1, |
| kOffPremiseServicesReachableIPv4 = 2, |
| kOffPremiseServicesReachableIPv6 = 3, |
| kHardwareAddress = 4, |
| kIPv4Addresses = 5, |
| kIPv6Addresses = 6, |
| kType = 7, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::CharSpan name; |
| bool isOperational = static_cast<bool>(0); |
| DataModel::Nullable<bool> offPremiseServicesReachableIPv4; |
| DataModel::Nullable<bool> offPremiseServicesReachableIPv6; |
| chip::ByteSpan hardwareAddress; |
| DataModel::List<const chip::ByteSpan> IPv4Addresses; |
| DataModel::List<const chip::ByteSpan> IPv6Addresses; |
| InterfaceType type = static_cast<InterfaceType>(0); |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| chip::CharSpan name; |
| bool isOperational = static_cast<bool>(0); |
| DataModel::Nullable<bool> offPremiseServicesReachableIPv4; |
| DataModel::Nullable<bool> offPremiseServicesReachableIPv6; |
| chip::ByteSpan hardwareAddress; |
| DataModel::DecodableList<chip::ByteSpan> IPv4Addresses; |
| DataModel::DecodableList<chip::ByteSpan> IPv6Addresses; |
| InterfaceType type = static_cast<InterfaceType>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| }; |
| |
| } // namespace NetworkInterfaceType |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace TestEventTrigger { |
| struct Type; |
| struct DecodableType; |
| } // namespace TestEventTrigger |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace TestEventTrigger { |
| enum class Fields |
| { |
| kEnableKey = 0, |
| kEventTrigger = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::TestEventTrigger::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| |
| chip::ByteSpan enableKey; |
| uint64_t eventTrigger = static_cast<uint64_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::TestEventTrigger::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| |
| chip::ByteSpan enableKey; |
| uint64_t eventTrigger = static_cast<uint64_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace TestEventTrigger |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace NetworkInterfaces { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList< |
| chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NetworkInterfaces::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace NetworkInterfaces |
| namespace RebootCount { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RebootCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RebootCount |
| namespace UpTime { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::UpTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace UpTime |
| namespace TotalOperationalHours { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TotalOperationalHours::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TotalOperationalHours |
| namespace BootReasons { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BootReasons::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BootReasons |
| namespace ActiveHardwareFaults { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const uint8_t>; |
| using DecodableType = chip::app::DataModel::DecodableList<uint8_t>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<uint8_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveHardwareFaults::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActiveHardwareFaults |
| namespace ActiveRadioFaults { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const uint8_t>; |
| using DecodableType = chip::app::DataModel::DecodableList<uint8_t>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<uint8_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveRadioFaults::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActiveRadioFaults |
| namespace ActiveNetworkFaults { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const uint8_t>; |
| using DecodableType = chip::app::DataModel::DecodableList<uint8_t>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<uint8_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveNetworkFaults::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActiveNetworkFaults |
| namespace TestEventTriggersEnabled { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TestEventTriggersEnabled::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TestEventTriggersEnabled |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::NetworkInterfaces::TypeInfo::DecodableType networkInterfaces; |
| Attributes::RebootCount::TypeInfo::DecodableType rebootCount = static_cast<uint16_t>(0); |
| Attributes::UpTime::TypeInfo::DecodableType upTime = static_cast<uint64_t>(0); |
| Attributes::TotalOperationalHours::TypeInfo::DecodableType totalOperationalHours = static_cast<uint32_t>(0); |
| Attributes::BootReasons::TypeInfo::DecodableType bootReasons = static_cast<uint8_t>(0); |
| Attributes::ActiveHardwareFaults::TypeInfo::DecodableType activeHardwareFaults; |
| Attributes::ActiveRadioFaults::TypeInfo::DecodableType activeRadioFaults; |
| Attributes::ActiveNetworkFaults::TypeInfo::DecodableType activeNetworkFaults; |
| Attributes::TestEventTriggersEnabled::TypeInfo::DecodableType testEventTriggersEnabled = static_cast<bool>(0); |
| Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList; |
| Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList; |
| Attributes::AttributeList::TypeInfo::DecodableType attributeList; |
| Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0); |
| Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0); |
| }; |
| }; |
| } // namespace Attributes |
| namespace Events { |
| namespace HardwareFaultChange { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical; |
| |
| enum class Fields |
| { |
| kCurrent = 0, |
| kPrevious = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::HardwareFaultChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| DataModel::List<const HardwareFaultType> current; |
| DataModel::List<const HardwareFaultType> previous; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::HardwareFaultChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| |
| DataModel::DecodableList<HardwareFaultType> current; |
| DataModel::DecodableList<HardwareFaultType> previous; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace HardwareFaultChange |
| namespace RadioFaultChange { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical; |
| |
| enum class Fields |
| { |
| kCurrent = 0, |
| kPrevious = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::RadioFaultChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| DataModel::List<const RadioFaultType> current; |
| DataModel::List<const RadioFaultType> previous; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::RadioFaultChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| |
| DataModel::DecodableList<RadioFaultType> current; |
| DataModel::DecodableList<RadioFaultType> previous; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace RadioFaultChange |
| namespace NetworkFaultChange { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical; |
| |
| enum class Fields |
| { |
| kCurrent = 0, |
| kPrevious = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::NetworkFaultChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| DataModel::List<const NetworkFaultType> current; |
| DataModel::List<const NetworkFaultType> previous; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::NetworkFaultChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| |
| DataModel::DecodableList<NetworkFaultType> current; |
| DataModel::DecodableList<NetworkFaultType> previous; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace NetworkFaultChange |
| namespace BootReason { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical; |
| |
| enum class Fields |
| { |
| kBootReason = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::BootReason::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| BootReasonType bootReason = static_cast<BootReasonType>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::BootReason::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } |
| |
| BootReasonType bootReason = static_cast<BootReasonType>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace BootReason |
| } // namespace Events |
| } // namespace GeneralDiagnostics |
| namespace SoftwareDiagnostics { |
| namespace Structs { |
| namespace ThreadMetrics { |
| enum class Fields |
| { |
| kId = 0, |
| kName = 1, |
| kStackFreeCurrent = 2, |
| kStackFreeMinimum = 3, |
| kStackSize = 4, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint64_t id = static_cast<uint64_t>(0); |
| Optional<chip::CharSpan> name; |
| Optional<uint32_t> stackFreeCurrent; |
| Optional<uint32_t> stackFreeMinimum; |
| Optional<uint32_t> stackSize; |
| |
| 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 ThreadMetrics |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace ResetWatermarks { |
| struct Type; |
| struct DecodableType; |
| } // namespace ResetWatermarks |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace ResetWatermarks { |
| 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::ResetWatermarks::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::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::ResetWatermarks::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ResetWatermarks |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace ThreadMetrics { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetrics::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetrics::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList< |
| chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetrics::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ThreadMetrics::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ThreadMetrics |
| namespace CurrentHeapFree { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHeapFree::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentHeapFree |
| namespace CurrentHeapUsed { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHeapUsed::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentHeapUsed |
| namespace CurrentHeapHighWatermark { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentHeapHighWatermark::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentHeapHighWatermark |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::ThreadMetrics::TypeInfo::DecodableType threadMetrics; |
| Attributes::CurrentHeapFree::TypeInfo::DecodableType currentHeapFree = static_cast<uint64_t>(0); |
| Attributes::CurrentHeapUsed::TypeInfo::DecodableType currentHeapUsed = static_cast<uint64_t>(0); |
| Attributes::CurrentHeapHighWatermark::TypeInfo::DecodableType currentHeapHighWatermark = static_cast<uint64_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 Events { |
| namespace SoftwareFault { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kId = 0, |
| kName = 1, |
| kFaultRecording = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::SoftwareFault::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint64_t id = static_cast<uint64_t>(0); |
| Optional<chip::CharSpan> name; |
| Optional<chip::ByteSpan> faultRecording; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::SoftwareFault::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } |
| |
| uint64_t id = static_cast<uint64_t>(0); |
| Optional<chip::CharSpan> name; |
| Optional<chip::ByteSpan> faultRecording; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace SoftwareFault |
| } // namespace Events |
| } // namespace SoftwareDiagnostics |
| namespace ThreadNetworkDiagnostics { |
| namespace Structs { |
| namespace NeighborTable { |
| enum class Fields |
| { |
| kExtAddress = 0, |
| kAge = 1, |
| kRloc16 = 2, |
| kLinkFrameCounter = 3, |
| kMleFrameCounter = 4, |
| kLqi = 5, |
| kAverageRssi = 6, |
| kLastRssi = 7, |
| kFrameErrorRate = 8, |
| kMessageErrorRate = 9, |
| kRxOnWhenIdle = 10, |
| kFullThreadDevice = 11, |
| kFullNetworkData = 12, |
| kIsChild = 13, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint64_t extAddress = static_cast<uint64_t>(0); |
| uint32_t age = static_cast<uint32_t>(0); |
| uint16_t rloc16 = static_cast<uint16_t>(0); |
| uint32_t linkFrameCounter = static_cast<uint32_t>(0); |
| uint32_t mleFrameCounter = static_cast<uint32_t>(0); |
| uint8_t lqi = static_cast<uint8_t>(0); |
| DataModel::Nullable<int8_t> averageRssi; |
| DataModel::Nullable<int8_t> lastRssi; |
| uint8_t frameErrorRate = static_cast<uint8_t>(0); |
| uint8_t messageErrorRate = static_cast<uint8_t>(0); |
| bool rxOnWhenIdle = static_cast<bool>(0); |
| bool fullThreadDevice = static_cast<bool>(0); |
| bool fullNetworkData = static_cast<bool>(0); |
| bool isChild = static_cast<bool>(0); |
| |
| 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 NeighborTable |
| namespace OperationalDatasetComponents { |
| enum class Fields |
| { |
| kActiveTimestampPresent = 0, |
| kPendingTimestampPresent = 1, |
| kMasterKeyPresent = 2, |
| kNetworkNamePresent = 3, |
| kExtendedPanIdPresent = 4, |
| kMeshLocalPrefixPresent = 5, |
| kDelayPresent = 6, |
| kPanIdPresent = 7, |
| kChannelPresent = 8, |
| kPskcPresent = 9, |
| kSecurityPolicyPresent = 10, |
| kChannelMaskPresent = 11, |
| }; |
| |
| struct Type |
| { |
| public: |
| bool activeTimestampPresent = static_cast<bool>(0); |
| bool pendingTimestampPresent = static_cast<bool>(0); |
| bool masterKeyPresent = static_cast<bool>(0); |
| bool networkNamePresent = static_cast<bool>(0); |
| bool extendedPanIdPresent = static_cast<bool>(0); |
| bool meshLocalPrefixPresent = static_cast<bool>(0); |
| bool delayPresent = static_cast<bool>(0); |
| bool panIdPresent = static_cast<bool>(0); |
| bool channelPresent = static_cast<bool>(0); |
| bool pskcPresent = static_cast<bool>(0); |
| bool securityPolicyPresent = static_cast<bool>(0); |
| bool channelMaskPresent = static_cast<bool>(0); |
| |
| 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 OperationalDatasetComponents |
| namespace RouteTable { |
| enum class Fields |
| { |
| kExtAddress = 0, |
| kRloc16 = 1, |
| kRouterId = 2, |
| kNextHop = 3, |
| kPathCost = 4, |
| kLQIIn = 5, |
| kLQIOut = 6, |
| kAge = 7, |
| kAllocated = 8, |
| kLinkEstablished = 9, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint64_t extAddress = static_cast<uint64_t>(0); |
| uint16_t rloc16 = static_cast<uint16_t>(0); |
| uint8_t routerId = static_cast<uint8_t>(0); |
| uint8_t nextHop = static_cast<uint8_t>(0); |
| uint8_t pathCost = static_cast<uint8_t>(0); |
| uint8_t LQIIn = static_cast<uint8_t>(0); |
| uint8_t LQIOut = static_cast<uint8_t>(0); |
| uint8_t age = static_cast<uint8_t>(0); |
| bool allocated = static_cast<bool>(0); |
| bool linkEstablished = static_cast<bool>(0); |
| |
| 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 RouteTable |
| namespace SecurityPolicy { |
| enum class Fields |
| { |
| kRotationTime = 0, |
| kFlags = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint16_t rotationTime = static_cast<uint16_t>(0); |
| uint16_t flags = static_cast<uint16_t>(0); |
| |
| 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 SecurityPolicy |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace ResetCounts { |
| struct Type; |
| struct DecodableType; |
| } // namespace ResetCounts |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace ResetCounts { |
| 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::ResetCounts::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::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::ResetCounts::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ResetCounts |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace Channel { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Channel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Channel |
| namespace RoutingRole { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RoutingRole::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RoutingRole |
| namespace NetworkName { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::CharSpan>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::CharSpan>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::CharSpan> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NetworkName::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 16; } |
| }; |
| } // namespace NetworkName |
| namespace PanId { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PanId::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PanId |
| namespace ExtendedPanId { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ExtendedPanId::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ExtendedPanId |
| namespace MeshLocalPrefix { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::ByteSpan>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::MeshLocalPrefix::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 17; } |
| }; |
| } // namespace MeshLocalPrefix |
| namespace OverrunCount { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OverrunCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OverrunCount |
| namespace NeighborTableList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList< |
| chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NeighborTableList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace NeighborTableList |
| namespace RouteTableList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList< |
| chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RouteTableList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RouteTableList |
| namespace PartitionId { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PartitionId::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PartitionId |
| namespace Weighting { |
| 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::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Weighting::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Weighting |
| namespace DataVersion { |
| 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::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::DataVersion::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace DataVersion |
| namespace StableDataVersion { |
| 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::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::StableDataVersion::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace StableDataVersion |
| namespace LeaderRouterId { |
| 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::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LeaderRouterId::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LeaderRouterId |
| namespace DetachedRoleCount { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::DetachedRoleCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace DetachedRoleCount |
| namespace ChildRoleCount { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ChildRoleCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ChildRoleCount |
| namespace RouterRoleCount { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RouterRoleCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RouterRoleCount |
| namespace LeaderRoleCount { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LeaderRoleCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LeaderRoleCount |
| namespace AttachAttemptCount { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::AttachAttemptCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace AttachAttemptCount |
| namespace PartitionIdChangeCount { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PartitionIdChangeCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PartitionIdChangeCount |
| namespace BetterPartitionAttachAttemptCount { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BetterPartitionAttachAttemptCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BetterPartitionAttachAttemptCount |
| namespace ParentChangeCount { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ParentChangeCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ParentChangeCount |
| namespace TxTotalCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxTotalCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxTotalCount |
| namespace TxUnicastCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxUnicastCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxUnicastCount |
| namespace TxBroadcastCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxBroadcastCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxBroadcastCount |
| namespace TxAckRequestedCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxAckRequestedCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxAckRequestedCount |
| namespace TxAckedCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxAckedCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxAckedCount |
| namespace TxNoAckRequestedCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxNoAckRequestedCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxNoAckRequestedCount |
| namespace TxDataCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxDataCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxDataCount |
| namespace TxDataPollCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxDataPollCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxDataPollCount |
| namespace TxBeaconCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxBeaconCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxBeaconCount |
| namespace TxBeaconRequestCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxBeaconRequestCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxBeaconRequestCount |
| namespace TxOtherCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxOtherCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxOtherCount |
| namespace TxRetryCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxRetryCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxRetryCount |
| namespace TxDirectMaxRetryExpiryCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxDirectMaxRetryExpiryCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxDirectMaxRetryExpiryCount |
| namespace TxIndirectMaxRetryExpiryCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxIndirectMaxRetryExpiryCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxIndirectMaxRetryExpiryCount |
| namespace TxErrCcaCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxErrCcaCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxErrCcaCount |
| namespace TxErrAbortCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxErrAbortCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxErrAbortCount |
| namespace TxErrBusyChannelCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxErrBusyChannelCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxErrBusyChannelCount |
| namespace RxTotalCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxTotalCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxTotalCount |
| namespace RxUnicastCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxUnicastCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxUnicastCount |
| namespace RxBroadcastCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxBroadcastCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxBroadcastCount |
| namespace RxDataCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxDataCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxDataCount |
| namespace RxDataPollCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxDataPollCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxDataPollCount |
| namespace RxBeaconCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxBeaconCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxBeaconCount |
| namespace RxBeaconRequestCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxBeaconRequestCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxBeaconRequestCount |
| namespace RxOtherCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxOtherCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxOtherCount |
| namespace RxAddressFilteredCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxAddressFilteredCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxAddressFilteredCount |
| namespace RxDestAddrFilteredCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxDestAddrFilteredCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxDestAddrFilteredCount |
| namespace RxDuplicatedCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxDuplicatedCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxDuplicatedCount |
| namespace RxErrNoFrameCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxErrNoFrameCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxErrNoFrameCount |
| namespace RxErrUnknownNeighborCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxErrUnknownNeighborCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxErrUnknownNeighborCount |
| namespace RxErrInvalidSrcAddrCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxErrInvalidSrcAddrCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxErrInvalidSrcAddrCount |
| namespace RxErrSecCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxErrSecCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxErrSecCount |
| namespace RxErrFcsCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxErrFcsCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxErrFcsCount |
| namespace RxErrOtherCount { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::RxErrOtherCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace RxErrOtherCount |
| namespace ActiveTimestamp { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveTimestamp::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActiveTimestamp |
| namespace PendingTimestamp { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PendingTimestamp::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PendingTimestamp |
| namespace Delay { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Delay::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Delay |
| namespace SecurityPolicy { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::Type>; |
| using DecodableType = |
| chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::Nullable< |
| chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SecurityPolicy::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SecurityPolicy |
| namespace ChannelPage0Mask { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::ByteSpan>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ChannelPage0Mask::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 4; } |
| }; |
| } // namespace ChannelPage0Mask |
| namespace OperationalDatasetComponents { |
| struct TypeInfo |
| { |
| using Type = |
| chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::Type>; |
| using DecodableType = chip::app::DataModel::Nullable< |
| chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::Nullable< |
| chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OperationalDatasetComponents::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OperationalDatasetComponents |
| namespace ActiveNetworkFaultsList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ActiveNetworkFaultsList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ActiveNetworkFaultsList |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::Channel::TypeInfo::DecodableType channel; |
| Attributes::RoutingRole::TypeInfo::DecodableType routingRole; |
| Attributes::NetworkName::TypeInfo::DecodableType networkName; |
| Attributes::PanId::TypeInfo::DecodableType panId; |
| Attributes::ExtendedPanId::TypeInfo::DecodableType extendedPanId; |
| Attributes::MeshLocalPrefix::TypeInfo::DecodableType meshLocalPrefix; |
| Attributes::OverrunCount::TypeInfo::DecodableType overrunCount = static_cast<uint64_t>(0); |
| Attributes::NeighborTableList::TypeInfo::DecodableType neighborTableList; |
| Attributes::RouteTableList::TypeInfo::DecodableType routeTableList; |
| Attributes::PartitionId::TypeInfo::DecodableType partitionId; |
| Attributes::Weighting::TypeInfo::DecodableType weighting; |
| Attributes::DataVersion::TypeInfo::DecodableType dataVersion; |
| Attributes::StableDataVersion::TypeInfo::DecodableType stableDataVersion; |
| Attributes::LeaderRouterId::TypeInfo::DecodableType leaderRouterId; |
| Attributes::DetachedRoleCount::TypeInfo::DecodableType detachedRoleCount = static_cast<uint16_t>(0); |
| Attributes::ChildRoleCount::TypeInfo::DecodableType childRoleCount = static_cast<uint16_t>(0); |
| Attributes::RouterRoleCount::TypeInfo::DecodableType routerRoleCount = static_cast<uint16_t>(0); |
| Attributes::LeaderRoleCount::TypeInfo::DecodableType leaderRoleCount = static_cast<uint16_t>(0); |
| Attributes::AttachAttemptCount::TypeInfo::DecodableType attachAttemptCount = static_cast<uint16_t>(0); |
| Attributes::PartitionIdChangeCount::TypeInfo::DecodableType partitionIdChangeCount = static_cast<uint16_t>(0); |
| Attributes::BetterPartitionAttachAttemptCount::TypeInfo::DecodableType betterPartitionAttachAttemptCount = |
| static_cast<uint16_t>(0); |
| Attributes::ParentChangeCount::TypeInfo::DecodableType parentChangeCount = static_cast<uint16_t>(0); |
| Attributes::TxTotalCount::TypeInfo::DecodableType txTotalCount = static_cast<uint32_t>(0); |
| Attributes::TxUnicastCount::TypeInfo::DecodableType txUnicastCount = static_cast<uint32_t>(0); |
| Attributes::TxBroadcastCount::TypeInfo::DecodableType txBroadcastCount = static_cast<uint32_t>(0); |
| Attributes::TxAckRequestedCount::TypeInfo::DecodableType txAckRequestedCount = static_cast<uint32_t>(0); |
| Attributes::TxAckedCount::TypeInfo::DecodableType txAckedCount = static_cast<uint32_t>(0); |
| Attributes::TxNoAckRequestedCount::TypeInfo::DecodableType txNoAckRequestedCount = static_cast<uint32_t>(0); |
| Attributes::TxDataCount::TypeInfo::DecodableType txDataCount = static_cast<uint32_t>(0); |
| Attributes::TxDataPollCount::TypeInfo::DecodableType txDataPollCount = static_cast<uint32_t>(0); |
| Attributes::TxBeaconCount::TypeInfo::DecodableType txBeaconCount = static_cast<uint32_t>(0); |
| Attributes::TxBeaconRequestCount::TypeInfo::DecodableType txBeaconRequestCount = static_cast<uint32_t>(0); |
| Attributes::TxOtherCount::TypeInfo::DecodableType txOtherCount = static_cast<uint32_t>(0); |
| Attributes::TxRetryCount::TypeInfo::DecodableType txRetryCount = static_cast<uint32_t>(0); |
| Attributes::TxDirectMaxRetryExpiryCount::TypeInfo::DecodableType txDirectMaxRetryExpiryCount = static_cast<uint32_t>(0); |
| Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo::DecodableType txIndirectMaxRetryExpiryCount = static_cast<uint32_t>(0); |
| Attributes::TxErrCcaCount::TypeInfo::DecodableType txErrCcaCount = static_cast<uint32_t>(0); |
| Attributes::TxErrAbortCount::TypeInfo::DecodableType txErrAbortCount = static_cast<uint32_t>(0); |
| Attributes::TxErrBusyChannelCount::TypeInfo::DecodableType txErrBusyChannelCount = static_cast<uint32_t>(0); |
| Attributes::RxTotalCount::TypeInfo::DecodableType rxTotalCount = static_cast<uint32_t>(0); |
| Attributes::RxUnicastCount::TypeInfo::DecodableType rxUnicastCount = static_cast<uint32_t>(0); |
| Attributes::RxBroadcastCount::TypeInfo::DecodableType rxBroadcastCount = static_cast<uint32_t>(0); |
| Attributes::RxDataCount::TypeInfo::DecodableType rxDataCount = static_cast<uint32_t>(0); |
| Attributes::RxDataPollCount::TypeInfo::DecodableType rxDataPollCount = static_cast<uint32_t>(0); |
| Attributes::RxBeaconCount::TypeInfo::DecodableType rxBeaconCount = static_cast<uint32_t>(0); |
| Attributes::RxBeaconRequestCount::TypeInfo::DecodableType rxBeaconRequestCount = static_cast<uint32_t>(0); |
| Attributes::RxOtherCount::TypeInfo::DecodableType rxOtherCount = static_cast<uint32_t>(0); |
| Attributes::RxAddressFilteredCount::TypeInfo::DecodableType rxAddressFilteredCount = static_cast<uint32_t>(0); |
| Attributes::RxDestAddrFilteredCount::TypeInfo::DecodableType rxDestAddrFilteredCount = static_cast<uint32_t>(0); |
| Attributes::RxDuplicatedCount::TypeInfo::DecodableType rxDuplicatedCount = static_cast<uint32_t>(0); |
| Attributes::RxErrNoFrameCount::TypeInfo::DecodableType rxErrNoFrameCount = static_cast<uint32_t>(0); |
| Attributes::RxErrUnknownNeighborCount::TypeInfo::DecodableType rxErrUnknownNeighborCount = static_cast<uint32_t>(0); |
| Attributes::RxErrInvalidSrcAddrCount::TypeInfo::DecodableType rxErrInvalidSrcAddrCount = static_cast<uint32_t>(0); |
| Attributes::RxErrSecCount::TypeInfo::DecodableType rxErrSecCount = static_cast<uint32_t>(0); |
| Attributes::RxErrFcsCount::TypeInfo::DecodableType rxErrFcsCount = static_cast<uint32_t>(0); |
| Attributes::RxErrOtherCount::TypeInfo::DecodableType rxErrOtherCount = static_cast<uint32_t>(0); |
| Attributes::ActiveTimestamp::TypeInfo::DecodableType activeTimestamp; |
| Attributes::PendingTimestamp::TypeInfo::DecodableType pendingTimestamp; |
| Attributes::Delay::TypeInfo::DecodableType delay; |
| Attributes::SecurityPolicy::TypeInfo::DecodableType securityPolicy; |
| Attributes::ChannelPage0Mask::TypeInfo::DecodableType channelPage0Mask; |
| Attributes::OperationalDatasetComponents::TypeInfo::DecodableType operationalDatasetComponents; |
| Attributes::ActiveNetworkFaultsList::TypeInfo::DecodableType activeNetworkFaultsList; |
| 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 Events { |
| namespace ConnectionStatus { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kConnectionStatus = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ConnectionStatus::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| ThreadConnectionStatus connectionStatus = static_cast<ThreadConnectionStatus>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ConnectionStatus::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| |
| ThreadConnectionStatus connectionStatus = static_cast<ThreadConnectionStatus>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace ConnectionStatus |
| namespace NetworkFaultChange { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kCurrent = 0, |
| kPrevious = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::NetworkFaultChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| DataModel::List<const NetworkFault> current; |
| DataModel::List<const NetworkFault> previous; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::NetworkFaultChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } |
| |
| DataModel::DecodableList<NetworkFault> current; |
| DataModel::DecodableList<NetworkFault> previous; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace NetworkFaultChange |
| } // namespace Events |
| } // namespace ThreadNetworkDiagnostics |
| namespace WiFiNetworkDiagnostics { |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace ResetCounts { |
| struct Type; |
| struct DecodableType; |
| } // namespace ResetCounts |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace ResetCounts { |
| 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::ResetCounts::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::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::ResetCounts::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ResetCounts |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace Bssid { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::ByteSpan>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::ByteSpan>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::ByteSpan> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Bssid::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 6; } |
| }; |
| } // namespace Bssid |
| namespace SecurityType { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SecurityType::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SecurityType |
| namespace WiFiVersion { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::WiFiVersion::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace WiFiVersion |
| namespace ChannelNumber { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ChannelNumber::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace ChannelNumber |
| namespace Rssi { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<int8_t>; |
| using DecodableType = chip::app::DataModel::Nullable<int8_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<int8_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Rssi::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Rssi |
| namespace BeaconLostCount { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BeaconLostCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BeaconLostCount |
| namespace BeaconRxCount { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::BeaconRxCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace BeaconRxCount |
| namespace PacketMulticastRxCount { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PacketMulticastRxCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PacketMulticastRxCount |
| namespace PacketMulticastTxCount { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PacketMulticastTxCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PacketMulticastTxCount |
| namespace PacketUnicastRxCount { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PacketUnicastRxCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PacketUnicastRxCount |
| namespace PacketUnicastTxCount { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint32_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint32_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PacketUnicastTxCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PacketUnicastTxCount |
| namespace CurrentMaxRate { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentMaxRate::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentMaxRate |
| namespace OverrunCount { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OverrunCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OverrunCount |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::Bssid::TypeInfo::DecodableType bssid; |
| Attributes::SecurityType::TypeInfo::DecodableType securityType; |
| Attributes::WiFiVersion::TypeInfo::DecodableType wiFiVersion; |
| Attributes::ChannelNumber::TypeInfo::DecodableType channelNumber; |
| Attributes::Rssi::TypeInfo::DecodableType rssi; |
| Attributes::BeaconLostCount::TypeInfo::DecodableType beaconLostCount; |
| Attributes::BeaconRxCount::TypeInfo::DecodableType beaconRxCount; |
| Attributes::PacketMulticastRxCount::TypeInfo::DecodableType packetMulticastRxCount; |
| Attributes::PacketMulticastTxCount::TypeInfo::DecodableType packetMulticastTxCount; |
| Attributes::PacketUnicastRxCount::TypeInfo::DecodableType packetUnicastRxCount; |
| Attributes::PacketUnicastTxCount::TypeInfo::DecodableType packetUnicastTxCount; |
| Attributes::CurrentMaxRate::TypeInfo::DecodableType currentMaxRate; |
| Attributes::OverrunCount::TypeInfo::DecodableType overrunCount; |
| 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 Events { |
| namespace Disconnection { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kReasonCode = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::Disconnection::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint16_t reasonCode = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::Disconnection::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| |
| uint16_t reasonCode = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace Disconnection |
| namespace AssociationFailure { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kAssociationFailure = 0, |
| kStatus = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::AssociationFailure::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| AssociationFailureCause associationFailure = static_cast<AssociationFailureCause>(0); |
| uint16_t status = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::AssociationFailure::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| |
| AssociationFailureCause associationFailure = static_cast<AssociationFailureCause>(0); |
| uint16_t status = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace AssociationFailure |
| namespace ConnectionStatus { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kConnectionStatus = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ConnectionStatus::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| WiFiConnectionStatus connectionStatus = static_cast<WiFiConnectionStatus>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ConnectionStatus::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } |
| |
| WiFiConnectionStatus connectionStatus = static_cast<WiFiConnectionStatus>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace ConnectionStatus |
| } // namespace Events |
| } // namespace WiFiNetworkDiagnostics |
| namespace EthernetNetworkDiagnostics { |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace ResetCounts { |
| struct Type; |
| struct DecodableType; |
| } // namespace ResetCounts |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace ResetCounts { |
| 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::ResetCounts::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::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::ResetCounts::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ResetCounts |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace PHYRate { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PHYRate::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PHYRate |
| namespace FullDuplex { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<bool>; |
| using DecodableType = chip::app::DataModel::Nullable<bool>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<bool> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::FullDuplex::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace FullDuplex |
| namespace PacketRxCount { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PacketRxCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PacketRxCount |
| namespace PacketTxCount { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PacketTxCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace PacketTxCount |
| namespace TxErrCount { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TxErrCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TxErrCount |
| namespace CollisionCount { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CollisionCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CollisionCount |
| namespace OverrunCount { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::OverrunCount::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace OverrunCount |
| namespace CarrierDetect { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<bool>; |
| using DecodableType = chip::app::DataModel::Nullable<bool>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<bool> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CarrierDetect::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CarrierDetect |
| namespace TimeSinceReset { |
| struct TypeInfo |
| { |
| using Type = uint64_t; |
| using DecodableType = uint64_t; |
| using DecodableArgType = uint64_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TimeSinceReset::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TimeSinceReset |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::PHYRate::TypeInfo::DecodableType PHYRate; |
| Attributes::FullDuplex::TypeInfo::DecodableType fullDuplex; |
| Attributes::PacketRxCount::TypeInfo::DecodableType packetRxCount = static_cast<uint64_t>(0); |
| Attributes::PacketTxCount::TypeInfo::DecodableType packetTxCount = static_cast<uint64_t>(0); |
| Attributes::TxErrCount::TypeInfo::DecodableType txErrCount = static_cast<uint64_t>(0); |
| Attributes::CollisionCount::TypeInfo::DecodableType collisionCount = static_cast<uint64_t>(0); |
| Attributes::OverrunCount::TypeInfo::DecodableType overrunCount = static_cast<uint64_t>(0); |
| Attributes::CarrierDetect::TypeInfo::DecodableType carrierDetect; |
| Attributes::TimeSinceReset::TypeInfo::DecodableType timeSinceReset = static_cast<uint64_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 EthernetNetworkDiagnostics |
| namespace TimeSynchronization { |
| namespace Structs { |
| namespace DstOffsetType { |
| enum class Fields |
| { |
| kOffset = 0, |
| kValidStarting = 1, |
| kValidUntil = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| int32_t offset = static_cast<int32_t>(0); |
| uint64_t validStarting = static_cast<uint64_t>(0); |
| uint64_t validUntil = static_cast<uint64_t>(0); |
| |
| 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 DstOffsetType |
| namespace TimeZoneType { |
| enum class Fields |
| { |
| kOffset = 0, |
| kValidAt = 1, |
| kName = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| int32_t offset = static_cast<int32_t>(0); |
| uint64_t validAt = static_cast<uint64_t>(0); |
| Optional<chip::CharSpan> name; |
| |
| 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 TimeZoneType |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace SetUtcTime { |
| struct Type; |
| struct DecodableType; |
| } // namespace SetUtcTime |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace SetUtcTime { |
| enum class Fields |
| { |
| kUtcTime = 0, |
| kGranularity = 1, |
| kTimeSource = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::SetUtcTime::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| |
| uint64_t utcTime = static_cast<uint64_t>(0); |
| GranularityEnum granularity = static_cast<GranularityEnum>(0); |
| Optional<TimeSourceEnum> timeSource; |
| |
| 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::SetUtcTime::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| |
| uint64_t utcTime = static_cast<uint64_t>(0); |
| GranularityEnum granularity = static_cast<GranularityEnum>(0); |
| Optional<TimeSourceEnum> timeSource; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace SetUtcTime |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace UTCTime { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::UTCTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace UTCTime |
| namespace Granularity { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::TimeSynchronization::GranularityEnum; |
| using DecodableType = chip::app::Clusters::TimeSynchronization::GranularityEnum; |
| using DecodableArgType = chip::app::Clusters::TimeSynchronization::GranularityEnum; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Granularity::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Granularity |
| namespace TimeSource { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::TimeSynchronization::TimeSourceEnum; |
| using DecodableType = chip::app::Clusters::TimeSynchronization::TimeSourceEnum; |
| using DecodableArgType = chip::app::Clusters::TimeSynchronization::TimeSourceEnum; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TimeSource::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TimeSource |
| namespace TrustedTimeNodeId { |
| 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::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TrustedTimeNodeId::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TrustedTimeNodeId |
| namespace DefaultNtp { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::CharSpan>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::CharSpan>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::CharSpan> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::DefaultNtp::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 128; } |
| }; |
| } // namespace DefaultNtp |
| namespace TimeZone { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::TimeSynchronization::Structs::TimeZoneType::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::TimeSynchronization::Structs::TimeZoneType::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::TimeSynchronization::Structs::TimeZoneType::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TimeZone::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TimeZone |
| namespace DstOffset { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::TimeSynchronization::Structs::DstOffsetType::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::TimeSynchronization::Structs::DstOffsetType::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList< |
| chip::app::Clusters::TimeSynchronization::Structs::DstOffsetType::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::DstOffset::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace DstOffset |
| namespace LocalTime { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint64_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint64_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LocalTime::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LocalTime |
| namespace TimeZoneDatabase { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TimeZoneDatabase::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TimeZoneDatabase |
| namespace NtpServerPort { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NtpServerPort::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace NtpServerPort |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::UTCTime::TypeInfo::DecodableType UTCTime; |
| Attributes::Granularity::TypeInfo::DecodableType granularity = |
| static_cast<chip::app::Clusters::TimeSynchronization::GranularityEnum>(0); |
| Attributes::TimeSource::TypeInfo::DecodableType timeSource = |
| static_cast<chip::app::Clusters::TimeSynchronization::TimeSourceEnum>(0); |
| Attributes::TrustedTimeNodeId::TypeInfo::DecodableType trustedTimeNodeId; |
| Attributes::DefaultNtp::TypeInfo::DecodableType defaultNtp; |
| Attributes::TimeZone::TypeInfo::DecodableType timeZone; |
| Attributes::DstOffset::TypeInfo::DecodableType dstOffset; |
| Attributes::LocalTime::TypeInfo::DecodableType localTime; |
| Attributes::TimeZoneDatabase::TypeInfo::DecodableType timeZoneDatabase = static_cast<bool>(0); |
| Attributes::NtpServerPort::TypeInfo::DecodableType ntpServerPort; |
| 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 TimeSynchronization |
| namespace BridgedDeviceBasic { |
| |
| namespace Attributes { |
| |
| namespace VendorName { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::VendorName::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace VendorName |
| namespace VendorID { |
| struct TypeInfo |
| { |
| using Type = chip::VendorId; |
| using DecodableType = chip::VendorId; |
| using DecodableArgType = chip::VendorId; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::VendorID::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace VendorID |
| namespace ProductName { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ProductName::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace ProductName |
| namespace NodeLabel { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NodeLabel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace NodeLabel |
| namespace HardwareVersion { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersion::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace HardwareVersion |
| namespace HardwareVersionString { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::HardwareVersionString::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 64; } |
| }; |
| } // namespace HardwareVersionString |
| namespace SoftwareVersion { |
| struct TypeInfo |
| { |
| using Type = uint32_t; |
| using DecodableType = uint32_t; |
| using DecodableArgType = uint32_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersion::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SoftwareVersion |
| namespace SoftwareVersionString { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SoftwareVersionString::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 64; } |
| }; |
| } // namespace SoftwareVersionString |
| namespace ManufacturingDate { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ManufacturingDate::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 16; } |
| }; |
| } // namespace ManufacturingDate |
| namespace PartNumber { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::PartNumber::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace PartNumber |
| namespace ProductURL { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ProductURL::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 256; } |
| }; |
| } // namespace ProductURL |
| namespace ProductLabel { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::ProductLabel::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 64; } |
| }; |
| } // namespace ProductLabel |
| namespace SerialNumber { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SerialNumber::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace SerialNumber |
| namespace Reachable { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Reachable::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Reachable |
| namespace UniqueID { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::UniqueID::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace UniqueID |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::VendorName::TypeInfo::DecodableType vendorName; |
| Attributes::VendorID::TypeInfo::DecodableType vendorID = static_cast<chip::VendorId>(0); |
| Attributes::ProductName::TypeInfo::DecodableType productName; |
| Attributes::NodeLabel::TypeInfo::DecodableType nodeLabel; |
| Attributes::HardwareVersion::TypeInfo::DecodableType hardwareVersion = static_cast<uint16_t>(0); |
| Attributes::HardwareVersionString::TypeInfo::DecodableType hardwareVersionString; |
| Attributes::SoftwareVersion::TypeInfo::DecodableType softwareVersion = static_cast<uint32_t>(0); |
| Attributes::SoftwareVersionString::TypeInfo::DecodableType softwareVersionString; |
| Attributes::ManufacturingDate::TypeInfo::DecodableType manufacturingDate; |
| Attributes::PartNumber::TypeInfo::DecodableType partNumber; |
| Attributes::ProductURL::TypeInfo::DecodableType productURL; |
| Attributes::ProductLabel::TypeInfo::DecodableType productLabel; |
| Attributes::SerialNumber::TypeInfo::DecodableType serialNumber; |
| Attributes::Reachable::TypeInfo::DecodableType reachable = static_cast<bool>(0); |
| Attributes::UniqueID::TypeInfo::DecodableType uniqueID; |
| 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 Events { |
| namespace StartUp { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical; |
| |
| enum class Fields |
| { |
| kSoftwareVersion = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StartUp::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StartUp::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| |
| uint32_t softwareVersion = static_cast<uint32_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace StartUp |
| namespace ShutDown { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Critical; |
| |
| enum class Fields |
| { |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ShutDown::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ShutDown::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace ShutDown |
| namespace Leave { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::Leave::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::Leave::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace Leave |
| namespace ReachableChanged { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kReachableNewValue = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ReachableChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| bool reachableNewValue = static_cast<bool>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ReachableChanged::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } |
| |
| bool reachableNewValue = static_cast<bool>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace ReachableChanged |
| } // namespace Events |
| } // namespace BridgedDeviceBasic |
| namespace Switch { |
| |
| namespace Attributes { |
| |
| namespace NumberOfPositions { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NumberOfPositions::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace NumberOfPositions |
| namespace CurrentPosition { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentPosition::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentPosition |
| namespace MultiPressMax { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::MultiPressMax::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace MultiPressMax |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::NumberOfPositions::TypeInfo::DecodableType numberOfPositions = static_cast<uint8_t>(0); |
| Attributes::CurrentPosition::TypeInfo::DecodableType currentPosition = static_cast<uint8_t>(0); |
| Attributes::MultiPressMax::TypeInfo::DecodableType multiPressMax = 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 Events { |
| namespace SwitchLatched { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kNewPosition = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::SwitchLatched::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::SwitchLatched::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace SwitchLatched |
| namespace InitialPress { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kNewPosition = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::InitialPress::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::InitialPress::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace InitialPress |
| namespace LongPress { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kNewPosition = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::LongPress::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::LongPress::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace LongPress |
| namespace ShortRelease { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kPreviousPosition = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ShortRelease::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint8_t previousPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::ShortRelease::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| |
| uint8_t previousPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace ShortRelease |
| namespace LongRelease { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kPreviousPosition = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::LongRelease::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint8_t previousPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::LongRelease::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| |
| uint8_t previousPosition = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace LongRelease |
| namespace MultiPressOngoing { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kNewPosition = 0, |
| kCurrentNumberOfPressesCounted = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::MultiPressOngoing::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| uint8_t currentNumberOfPressesCounted = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::MultiPressOngoing::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| uint8_t currentNumberOfPressesCounted = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace MultiPressOngoing |
| namespace MultiPressComplete { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kNewPosition = 0, |
| kTotalNumberOfPressesCounted = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::MultiPressComplete::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| uint8_t totalNumberOfPressesCounted = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::MultiPressComplete::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } |
| |
| uint8_t newPosition = static_cast<uint8_t>(0); |
| uint8_t totalNumberOfPressesCounted = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace MultiPressComplete |
| } // namespace Events |
| } // namespace Switch |
| namespace AdministratorCommissioning { |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace OpenCommissioningWindow { |
| struct Type; |
| struct DecodableType; |
| } // namespace OpenCommissioningWindow |
| |
| namespace OpenBasicCommissioningWindow { |
| struct Type; |
| struct DecodableType; |
| } // namespace OpenBasicCommissioningWindow |
| |
| namespace RevokeCommissioning { |
| struct Type; |
| struct DecodableType; |
| } // namespace RevokeCommissioning |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace OpenCommissioningWindow { |
| enum class Fields |
| { |
| kCommissioningTimeout = 0, |
| kPAKEVerifier = 1, |
| kDiscriminator = 2, |
| kIterations = 3, |
| kSalt = 4, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::OpenCommissioningWindow::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| |
| uint16_t commissioningTimeout = static_cast<uint16_t>(0); |
| chip::ByteSpan PAKEVerifier; |
| uint16_t discriminator = static_cast<uint16_t>(0); |
| uint32_t iterations = static_cast<uint32_t>(0); |
| chip::ByteSpan salt; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return true; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::OpenCommissioningWindow::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| |
| uint16_t commissioningTimeout = static_cast<uint16_t>(0); |
| chip::ByteSpan PAKEVerifier; |
| uint16_t discriminator = static_cast<uint16_t>(0); |
| uint32_t iterations = static_cast<uint32_t>(0); |
| chip::ByteSpan salt; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace OpenCommissioningWindow |
| namespace OpenBasicCommissioningWindow { |
| enum class Fields |
| { |
| kCommissioningTimeout = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::OpenBasicCommissioningWindow::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| |
| uint16_t commissioningTimeout = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return true; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::OpenBasicCommissioningWindow::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| |
| uint16_t commissioningTimeout = static_cast<uint16_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace OpenBasicCommissioningWindow |
| namespace RevokeCommissioning { |
| 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::RevokeCommissioning::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = DataModel::NullObjectType; |
| |
| static constexpr bool MustUseTimedInvoke() { return true; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RevokeCommissioning::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RevokeCommissioning |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace WindowStatus { |
| struct TypeInfo |
| { |
| using Type = chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus; |
| using DecodableType = chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus; |
| using DecodableArgType = chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::WindowStatus::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace WindowStatus |
| namespace AdminFabricIndex { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<chip::FabricIndex>; |
| using DecodableType = chip::app::DataModel::Nullable<chip::FabricIndex>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<chip::FabricIndex> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::AdminFabricIndex::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace AdminFabricIndex |
| namespace AdminVendorId { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::AdminVendorId::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace AdminVendorId |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::WindowStatus::TypeInfo::DecodableType windowStatus = |
| static_cast<chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus>(0); |
| Attributes::AdminFabricIndex::TypeInfo::DecodableType adminFabricIndex; |
| Attributes::AdminVendorId::TypeInfo::DecodableType adminVendorId; |
| 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 AdministratorCommissioning |
| namespace OperationalCredentials { |
| namespace Structs { |
| namespace FabricDescriptor { |
| enum class Fields |
| { |
| kRootPublicKey = 1, |
| kVendorId = 2, |
| kFabricId = 3, |
| kNodeId = 4, |
| kLabel = 5, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::ByteSpan rootPublicKey; |
| chip::VendorId vendorId = static_cast<chip::VendorId>(0); |
| chip::FabricId fabricId = static_cast<chip::FabricId>(0); |
| chip::NodeId nodeId = static_cast<chip::NodeId>(0); |
| chip::CharSpan label; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| |
| CHIP_ERROR EncodeForWrite(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| CHIP_ERROR EncodeForRead(TLV::TLVWriter & writer, TLV::Tag tag, FabricIndex accessingFabricIndex) const; |
| |
| private: |
| CHIP_ERROR DoEncode(TLV::TLVWriter & writer, TLV::Tag tag, const Optional<FabricIndex> & accessingFabricIndex) const; |
| }; |
| |
| using DecodableType = Type; |
| |
| } // namespace FabricDescriptor |
| namespace NOCStruct { |
| enum class Fields |
| { |
| kNoc = 1, |
| kIcac = 2, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::ByteSpan noc; |
| DataModel::Nullable<chip::ByteSpan> icac; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| |
| CHIP_ERROR EncodeForWrite(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| CHIP_ERROR EncodeForRead(TLV::TLVWriter & writer, TLV::Tag tag, FabricIndex accessingFabricIndex) const; |
| |
| private: |
| CHIP_ERROR DoEncode(TLV::TLVWriter & writer, TLV::Tag tag, const Optional<FabricIndex> & accessingFabricIndex) const; |
| }; |
| |
| using DecodableType = Type; |
| |
| } // namespace NOCStruct |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace AttestationRequest { |
| struct Type; |
| struct DecodableType; |
| } // namespace AttestationRequest |
| |
| namespace AttestationResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace AttestationResponse |
| |
| namespace CertificateChainRequest { |
| struct Type; |
| struct DecodableType; |
| } // namespace CertificateChainRequest |
| |
| namespace CertificateChainResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace CertificateChainResponse |
| |
| namespace CSRRequest { |
| struct Type; |
| struct DecodableType; |
| } // namespace CSRRequest |
| |
| namespace CSRResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace CSRResponse |
| |
| namespace AddNOC { |
| struct Type; |
| struct DecodableType; |
| } // namespace AddNOC |
| |
| namespace UpdateNOC { |
| struct Type; |
| struct DecodableType; |
| } // namespace UpdateNOC |
| |
| namespace NOCResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace NOCResponse |
| |
| namespace UpdateFabricLabel { |
| struct Type; |
| struct DecodableType; |
| } // namespace UpdateFabricLabel |
| |
| namespace RemoveFabric { |
| struct Type; |
| struct DecodableType; |
| } // namespace RemoveFabric |
| |
| namespace AddTrustedRootCertificate { |
| struct Type; |
| struct DecodableType; |
| } // namespace AddTrustedRootCertificate |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace AttestationRequest { |
| enum class Fields |
| { |
| kAttestationNonce = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AttestationRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan attestationNonce; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::OperationalCredentials::Commands::AttestationResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::AttestationRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan attestationNonce; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AttestationRequest |
| namespace AttestationResponse { |
| enum class Fields |
| { |
| kAttestationElements = 0, |
| kSignature = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AttestationResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan attestationElements; |
| chip::ByteSpan signature; |
| |
| 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::AttestationResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan attestationElements; |
| chip::ByteSpan signature; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AttestationResponse |
| namespace CertificateChainRequest { |
| enum class Fields |
| { |
| kCertificateType = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::CertificateChainRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| uint8_t certificateType = static_cast<uint8_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::OperationalCredentials::Commands::CertificateChainResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::CertificateChainRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| uint8_t certificateType = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace CertificateChainRequest |
| namespace CertificateChainResponse { |
| enum class Fields |
| { |
| kCertificate = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::CertificateChainResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan certificate; |
| |
| 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::CertificateChainResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan certificate; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace CertificateChainResponse |
| namespace CSRRequest { |
| enum class Fields |
| { |
| kCSRNonce = 0, |
| kIsForUpdateNOC = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::CSRRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan CSRNonce; |
| Optional<bool> isForUpdateNOC; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::OperationalCredentials::Commands::CSRResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::CSRRequest::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan CSRNonce; |
| Optional<bool> isForUpdateNOC; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace CSRRequest |
| namespace CSRResponse { |
| enum class Fields |
| { |
| kNOCSRElements = 0, |
| kAttestationSignature = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::CSRResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan NOCSRElements; |
| chip::ByteSpan attestationSignature; |
| |
| 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::CSRResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan NOCSRElements; |
| chip::ByteSpan attestationSignature; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace CSRResponse |
| namespace AddNOC { |
| enum class Fields |
| { |
| kNOCValue = 0, |
| kICACValue = 1, |
| kIPKValue = 2, |
| kCaseAdminSubject = 3, |
| kAdminVendorId = 4, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AddNOC::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan NOCValue; |
| Optional<chip::ByteSpan> ICACValue; |
| chip::ByteSpan IPKValue; |
| uint64_t caseAdminSubject = static_cast<uint64_t>(0); |
| chip::VendorId adminVendorId = static_cast<chip::VendorId>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::AddNOC::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan NOCValue; |
| Optional<chip::ByteSpan> ICACValue; |
| chip::ByteSpan IPKValue; |
| uint64_t caseAdminSubject = static_cast<uint64_t>(0); |
| chip::VendorId adminVendorId = static_cast<chip::VendorId>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AddNOC |
| namespace UpdateNOC { |
| enum class Fields |
| { |
| kNOCValue = 0, |
| kICACValue = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::UpdateNOC::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan NOCValue; |
| Optional<chip::ByteSpan> ICACValue; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::UpdateNOC::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan NOCValue; |
| Optional<chip::ByteSpan> ICACValue; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace UpdateNOC |
| namespace NOCResponse { |
| enum class Fields |
| { |
| kStatusCode = 0, |
| kFabricIndex = 1, |
| kDebugText = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::NOCResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| OperationalCertStatus statusCode = static_cast<OperationalCertStatus>(0); |
| Optional<chip::FabricIndex> fabricIndex; |
| Optional<chip::CharSpan> debugText; |
| |
| 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::NOCResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| OperationalCertStatus statusCode = static_cast<OperationalCertStatus>(0); |
| Optional<chip::FabricIndex> fabricIndex; |
| Optional<chip::CharSpan> debugText; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace NOCResponse |
| namespace UpdateFabricLabel { |
| enum class Fields |
| { |
| kLabel = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::UpdateFabricLabel::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::CharSpan label; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::UpdateFabricLabel::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::CharSpan label; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace UpdateFabricLabel |
| namespace RemoveFabric { |
| enum class Fields |
| { |
| kFabricIndex = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::RemoveFabric::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::RemoveFabric::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace RemoveFabric |
| namespace AddTrustedRootCertificate { |
| enum class Fields |
| { |
| kRootCertificate = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::AddTrustedRootCertificate::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan rootCertificate; |
| |
| 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::AddTrustedRootCertificate::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| chip::ByteSpan rootCertificate; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace AddTrustedRootCertificate |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace NOCs { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::NOCs::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace NOCs |
| namespace Fabrics { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList< |
| chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Fabrics::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace Fabrics |
| namespace SupportedFabrics { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SupportedFabrics::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SupportedFabrics |
| namespace CommissionedFabrics { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CommissionedFabrics::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CommissionedFabrics |
| namespace TrustedRootCertificates { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::ByteSpan>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::ByteSpan>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList<chip::ByteSpan> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::TrustedRootCertificates::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace TrustedRootCertificates |
| namespace CurrentFabricIndex { |
| struct TypeInfo |
| { |
| using Type = uint8_t; |
| using DecodableType = uint8_t; |
| using DecodableArgType = uint8_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::CurrentFabricIndex::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace CurrentFabricIndex |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::NOCs::TypeInfo::DecodableType NOCs; |
| Attributes::Fabrics::TypeInfo::DecodableType fabrics; |
| Attributes::SupportedFabrics::TypeInfo::DecodableType supportedFabrics = static_cast<uint8_t>(0); |
| Attributes::CommissionedFabrics::TypeInfo::DecodableType commissionedFabrics = static_cast<uint8_t>(0); |
| Attributes::TrustedRootCertificates::TypeInfo::DecodableType trustedRootCertificates; |
| Attributes::CurrentFabricIndex::TypeInfo::DecodableType currentFabricIndex = 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 OperationalCredentials |
| namespace GroupKeyManagement { |
| namespace Structs { |
| namespace GroupInfoMapStruct { |
| enum class Fields |
| { |
| kGroupId = 1, |
| kEndpoints = 2, |
| kGroupName = 3, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::GroupId groupId = static_cast<chip::GroupId>(0); |
| DataModel::List<const chip::EndpointId> endpoints; |
| Optional<chip::CharSpan> groupName; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| |
| CHIP_ERROR EncodeForWrite(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| CHIP_ERROR EncodeForRead(TLV::TLVWriter & writer, TLV::Tag tag, FabricIndex accessingFabricIndex) const; |
| |
| private: |
| CHIP_ERROR DoEncode(TLV::TLVWriter & writer, TLV::Tag tag, const Optional<FabricIndex> & accessingFabricIndex) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| chip::GroupId groupId = static_cast<chip::GroupId>(0); |
| DataModel::DecodableList<chip::EndpointId> endpoints; |
| Optional<chip::CharSpan> groupName; |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| }; |
| |
| } // namespace GroupInfoMapStruct |
| namespace GroupKeyMapStruct { |
| enum class Fields |
| { |
| kGroupId = 1, |
| kGroupKeySetID = 2, |
| kFabricIndex = 254, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::GroupId groupId = static_cast<chip::GroupId>(0); |
| uint16_t groupKeySetID = static_cast<uint16_t>(0); |
| chip::FabricIndex fabricIndex = static_cast<chip::FabricIndex>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = true; |
| |
| auto GetFabricIndex() const { return fabricIndex; } |
| |
| void SetFabricIndex(chip::FabricIndex fabricIndex_) { fabricIndex = fabricIndex_; } |
| |
| CHIP_ERROR EncodeForWrite(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| CHIP_ERROR EncodeForRead(TLV::TLVWriter & writer, TLV::Tag tag, FabricIndex accessingFabricIndex) const; |
| |
| private: |
| CHIP_ERROR DoEncode(TLV::TLVWriter & writer, TLV::Tag tag, const Optional<FabricIndex> & accessingFabricIndex) const; |
| }; |
| |
| using DecodableType = Type; |
| |
| } // namespace GroupKeyMapStruct |
| namespace GroupKeySetStruct { |
| enum class Fields |
| { |
| kGroupKeySetID = 0, |
| kGroupKeySecurityPolicy = 1, |
| kEpochKey0 = 2, |
| kEpochStartTime0 = 3, |
| kEpochKey1 = 4, |
| kEpochStartTime1 = 5, |
| kEpochKey2 = 6, |
| kEpochStartTime2 = 7, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint16_t groupKeySetID = static_cast<uint16_t>(0); |
| GroupKeySecurityPolicy groupKeySecurityPolicy = static_cast<GroupKeySecurityPolicy>(0); |
| DataModel::Nullable<chip::ByteSpan> epochKey0; |
| DataModel::Nullable<uint64_t> epochStartTime0; |
| DataModel::Nullable<chip::ByteSpan> epochKey1; |
| DataModel::Nullable<uint64_t> epochStartTime1; |
| DataModel::Nullable<chip::ByteSpan> epochKey2; |
| DataModel::Nullable<uint64_t> epochStartTime2; |
| |
| 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 GroupKeySetStruct |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace KeySetWrite { |
| struct Type; |
| struct DecodableType; |
| } // namespace KeySetWrite |
| |
| namespace KeySetRead { |
| struct Type; |
| struct DecodableType; |
| } // namespace KeySetRead |
| |
| namespace KeySetReadResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace KeySetReadResponse |
| |
| namespace KeySetRemove { |
| struct Type; |
| struct DecodableType; |
| } // namespace KeySetRemove |
| |
| namespace KeySetReadAllIndices { |
| struct Type; |
| struct DecodableType; |
| } // namespace KeySetReadAllIndices |
| |
| namespace KeySetReadAllIndicesResponse { |
| struct Type; |
| struct DecodableType; |
| } // namespace KeySetReadAllIndicesResponse |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace KeySetWrite { |
| enum class Fields |
| { |
| kGroupKeySet = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::KeySetWrite::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| Structs::GroupKeySetStruct::Type groupKeySet; |
| |
| 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::KeySetWrite::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| Structs::GroupKeySetStruct::DecodableType groupKeySet; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace KeySetWrite |
| namespace KeySetRead { |
| enum class Fields |
| { |
| kGroupKeySetID = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::KeySetRead::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| uint16_t groupKeySetID = static_cast<uint16_t>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::GroupKeyManagement::Commands::KeySetReadResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::KeySetRead::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| uint16_t groupKeySetID = static_cast<uint16_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace KeySetRead |
| namespace KeySetReadResponse { |
| enum class Fields |
| { |
| kGroupKeySet = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::KeySetReadResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| Structs::GroupKeySetStruct::Type groupKeySet; |
| |
| 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::KeySetReadResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| Structs::GroupKeySetStruct::DecodableType groupKeySet; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace KeySetReadResponse |
| namespace KeySetRemove { |
| enum class Fields |
| { |
| kGroupKeySetID = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::KeySetRemove::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| uint16_t groupKeySetID = 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::KeySetRemove::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| uint16_t groupKeySetID = static_cast<uint16_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace KeySetRemove |
| namespace KeySetReadAllIndices { |
| enum class Fields |
| { |
| kGroupKeySetIDs = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::KeySetReadAllIndices::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| DataModel::List<const uint16_t> groupKeySetIDs; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| |
| using ResponseType = Clusters::GroupKeyManagement::Commands::KeySetReadAllIndicesResponse::DecodableType; |
| |
| static constexpr bool MustUseTimedInvoke() { return false; } |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr CommandId GetCommandId() { return Commands::KeySetReadAllIndices::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| DataModel::DecodableList<uint16_t> groupKeySetIDs; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace KeySetReadAllIndices |
| namespace KeySetReadAllIndicesResponse { |
| enum class Fields |
| { |
| kGroupKeySetIDs = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::KeySetReadAllIndicesResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| DataModel::List<const uint16_t> groupKeySetIDs; |
| |
| 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::KeySetReadAllIndicesResponse::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| DataModel::DecodableList<uint16_t> groupKeySetIDs; |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace KeySetReadAllIndicesResponse |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace GroupKeyMap { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList< |
| chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::GroupKeyMap::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace GroupKeyMap |
| namespace GroupTable { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::DecodableType>; |
| using DecodableArgType = const chip::app::DataModel::DecodableList< |
| chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::GroupTable::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace GroupTable |
| namespace MaxGroupsPerFabric { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::MaxGroupsPerFabric::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace MaxGroupsPerFabric |
| namespace MaxGroupKeysPerFabric { |
| struct TypeInfo |
| { |
| using Type = uint16_t; |
| using DecodableType = uint16_t; |
| using DecodableArgType = uint16_t; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::MaxGroupKeysPerFabric::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace MaxGroupKeysPerFabric |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::GroupKeyMap::TypeInfo::DecodableType groupKeyMap; |
| Attributes::GroupTable::TypeInfo::DecodableType groupTable; |
| Attributes::MaxGroupsPerFabric::TypeInfo::DecodableType maxGroupsPerFabric = static_cast<uint16_t>(0); |
| Attributes::MaxGroupKeysPerFabric::TypeInfo::DecodableType maxGroupKeysPerFabric = static_cast<uint16_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 GroupKeyManagement |
| namespace FixedLabel { |
| namespace Structs { |
| namespace LabelStruct = Clusters::detail::Structs::LabelStruct; |
| } // namespace Structs |
| |
| namespace Attributes { |
| |
| namespace LabelList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::FixedLabel::Structs::LabelStruct::Type>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::FixedLabel::Structs::LabelStruct::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::FixedLabel::Structs::LabelStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LabelList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LabelList |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::LabelList::TypeInfo::DecodableType labelList; |
| 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 FixedLabel |
| namespace UserLabel { |
| namespace Structs { |
| namespace LabelStruct = Clusters::detail::Structs::LabelStruct; |
| } // namespace Structs |
| |
| namespace Attributes { |
| |
| namespace LabelList { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::UserLabel::Structs::LabelStruct::Type>; |
| using DecodableType = chip::app::DataModel::DecodableList<chip::app::Clusters::UserLabel::Structs::LabelStruct::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::UserLabel::Structs::LabelStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::LabelList::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace LabelList |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::LabelList::TypeInfo::DecodableType labelList; |
| 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 UserLabel |
| namespace ProxyConfiguration { |
| |
| namespace Attributes { |
| |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| 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 ProxyConfiguration |
| namespace ProxyDiscovery { |
| |
| namespace Attributes { |
| |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| 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 ProxyDiscovery |
| namespace ProxyValid { |
| |
| namespace Attributes { |
| |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| 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 ProxyValid |
| namespace BooleanState { |
| |
| namespace Attributes { |
| |
| namespace StateValue { |
| struct TypeInfo |
| { |
| using Type = bool; |
| using DecodableType = bool; |
| using DecodableArgType = bool; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::StateValue::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace StateValue |
| namespace GeneratedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } |
| }; |
| } // namespace GeneratedCommandList |
| namespace AcceptedCommandList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } |
| }; |
| } // namespace AcceptedCommandList |
| namespace AttributeList { |
| struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } |
| }; |
| } // namespace AttributeList |
| namespace FeatureMap { |
| struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } |
| }; |
| } // namespace FeatureMap |
| namespace ClusterRevision { |
| struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } |
| }; |
| } // namespace ClusterRevision |
| |
| struct TypeInfo |
| { |
| struct DecodableType |
| { |
| static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); |
| |
| Attributes::StateValue::TypeInfo::DecodableType stateValue = static_cast<bool>(0); |
| Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList; |
| Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList; |
| Attributes::AttributeList::TypeInfo::DecodableType attributeList; |
| Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast<uint32_t>(0); |
| Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast<uint16_t>(0); |
| }; |
| }; |
| } // namespace Attributes |
| namespace Events { |
| namespace StateChange { |
| static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; |
| |
| enum class Fields |
| { |
| kStateValue = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StateChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } |
| static constexpr bool kIsFabricScoped = false; |
| |
| bool stateValue = static_cast<bool>(0); |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } |
| static constexpr EventId GetEventId() { return Events::StateChange::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } |
| |
| bool stateValue = static_cast<bool>(0); |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| } // namespace StateChange |
| } // namespace Events |
| } // namespace BooleanState |
| namespace ModeSelect { |
| namespace Structs { |
| namespace SemanticTag { |
| enum class Fields |
| { |
| kMfgCode = 0, |
| kValue = 1, |
| }; |
| |
| struct Type |
| { |
| public: |
| uint16_t mfgCode = static_cast<uint16_t>(0); |
| uint16_t value = static_cast<uint16_t>(0); |
| |
| 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 SemanticTag |
| namespace ModeOptionStruct { |
| enum class Fields |
| { |
| kLabel = 0, |
| kMode = 1, |
| kSemanticTags = 2, |
| }; |
| |
| struct Type |
| { |
| public: |
| chip::CharSpan label; |
| uint8_t mode = static_cast<uint8_t>(0); |
| DataModel::List<const Structs::SemanticTag::Type> semanticTags; |
| |
| static constexpr bool kIsFabricScoped = false; |
| |
| CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; |
| }; |
| |
| struct DecodableType |
| { |
| public: |
| chip::CharSpan label; |
| uint8_t mode = static_cast<uint8_t>(0); |
| DataModel::DecodableList<Structs::SemanticTag::DecodableType> semanticTags; |
| |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| |
| static constexpr bool kIsFabricScoped = false; |
| }; |
| |
| } // namespace ModeOptionStruct |
| } // namespace Structs |
| |
| namespace Commands { |
| // Forward-declarations so we can reference these later. |
| |
| namespace ChangeToMode { |
| struct Type; |
| struct DecodableType; |
| } // namespace ChangeToMode |
| |
| } // namespace Commands |
| |
| namespace Commands { |
| namespace ChangeToMode { |
| enum class Fields |
| { |
| kNewMode = 0, |
| }; |
| |
| struct Type |
| { |
| public: |
| // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand |
| static constexpr CommandId GetCommandId() { return Commands::ChangeToMode::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; } |
| |
| uint8_t newMode = 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::ChangeToMode::Id; } |
| static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; } |
| |
| uint8_t newMode = static_cast<uint8_t>(0); |
| CHIP_ERROR Decode(TLV::TLVReader & reader); |
| }; |
| }; // namespace ChangeToMode |
| } // namespace Commands |
| |
| namespace Attributes { |
| |
| namespace Description { |
| struct TypeInfo |
| { |
| using Type = chip::CharSpan; |
| using DecodableType = chip::CharSpan; |
| using DecodableArgType = chip::CharSpan; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::Description::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| static constexpr size_t MaxLength() { return 32; } |
| }; |
| } // namespace Description |
| namespace StandardNamespace { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableType = chip::app::DataModel::Nullable<uint16_t>; |
| using DecodableArgType = const chip::app::DataModel::Nullable<uint16_t> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::StandardNamespace::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace StandardNamespace |
| namespace SupportedModes { |
| struct TypeInfo |
| { |
| using Type = chip::app::DataModel::List<const chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::Type>; |
| using DecodableType = |
| chip::app::DataModel::DecodableList<chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::DecodableType>; |
| using DecodableArgType = |
| const chip::app::DataModel::DecodableList<chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::DecodableType> &; |
| |
| static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; } |
| static constexpr AttributeId GetAttributeId() { return Attributes::SupportedModes::Id; } |
| static constexpr bool MustUseTimedWrite() { return false; } |
| }; |
| } // namespace SupportedModes |
|
