/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP
// This file is generated from clusters-Commands.h.zapt

#pragma once

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

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

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

#include <cstdint>

namespace chip {
namespace app {
namespace Clusters {
namespace ScenesManagement {
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 CopyScene {
struct Type;
struct DecodableType;
} // namespace CopyScene

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

} // namespace Commands

namespace Commands {
namespace AddScene {
enum class Fields : uint8_t {
  kGroupID = 0,
  kSceneID = 1,
  kTransitionTime = 2,
  kSceneName = 3,
  kExtensionFieldSetStructs = 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::ScenesManagement::Id;
  }

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);
  uint32_t transitionTime = static_cast<uint32_t>(0);
  chip::CharSpan sceneName;
  DataModel::List<const Structs::ExtensionFieldSetStruct::Type>
      extensionFieldSetStructs;

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

  using ResponseType =
      Clusters::ScenesManagement::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::ScenesManagement::Id;
  }
  static constexpr bool kIsFabricScoped = true;

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);
  uint32_t transitionTime = static_cast<uint32_t>(0);
  chip::CharSpan sceneName;
  DataModel::DecodableList<Structs::ExtensionFieldSetStruct::DecodableType>
      extensionFieldSetStructs;

  CHIP_ERROR Decode(TLV::TLVReader &reader, FabricIndex aAccessingFabricIndex);
};
}; // namespace AddScene
namespace AddSceneResponse {
enum class Fields : uint8_t {
  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::ScenesManagement::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(DataModel::FabricAwareTLVWriter &aWriter,
                    TLV::Tag aTag) const;

  using ResponseType = DataModel::NullObjectType;

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

struct DecodableType {
public:
  static constexpr CommandId GetCommandId() {
    return Commands::AddSceneResponse::Id;
  }
  static constexpr ClusterId GetClusterId() {
    return Clusters::ScenesManagement::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 : uint8_t {
  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::ScenesManagement::Id;
  }

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);

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

  using ResponseType =
      Clusters::ScenesManagement::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::ScenesManagement::Id;
  }
  static constexpr bool kIsFabricScoped = true;

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);

  CHIP_ERROR Decode(TLV::TLVReader &reader, FabricIndex aAccessingFabricIndex);
};
}; // namespace ViewScene
namespace ViewSceneResponse {
enum class Fields : uint8_t {
  kStatus = 0,
  kGroupID = 1,
  kSceneID = 2,
  kTransitionTime = 3,
  kSceneName = 4,
  kExtensionFieldSetStructs = 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::ScenesManagement::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<uint32_t> transitionTime;
  Optional<chip::CharSpan> sceneName;
  Optional<DataModel::List<const Structs::ExtensionFieldSetStruct::Type>>
      extensionFieldSetStructs;

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

  using ResponseType = DataModel::NullObjectType;

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

struct DecodableType {
public:
  static constexpr CommandId GetCommandId() {
    return Commands::ViewSceneResponse::Id;
  }
  static constexpr ClusterId GetClusterId() {
    return Clusters::ScenesManagement::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<uint32_t> transitionTime;
  Optional<chip::CharSpan> sceneName;
  Optional<
      DataModel::DecodableList<Structs::ExtensionFieldSetStruct::DecodableType>>
      extensionFieldSetStructs;

  CHIP_ERROR Decode(TLV::TLVReader &reader);
};
}; // namespace ViewSceneResponse
namespace RemoveScene {
enum class Fields : uint8_t {
  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::ScenesManagement::Id;
  }

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);

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

  using ResponseType =
      Clusters::ScenesManagement::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::ScenesManagement::Id;
  }
  static constexpr bool kIsFabricScoped = true;

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);

  CHIP_ERROR Decode(TLV::TLVReader &reader, FabricIndex aAccessingFabricIndex);
};
}; // namespace RemoveScene
namespace RemoveSceneResponse {
enum class Fields : uint8_t {
  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::ScenesManagement::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(DataModel::FabricAwareTLVWriter &aWriter,
                    TLV::Tag aTag) const;

  using ResponseType = DataModel::NullObjectType;

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

struct DecodableType {
public:
  static constexpr CommandId GetCommandId() {
    return Commands::RemoveSceneResponse::Id;
  }
  static constexpr ClusterId GetClusterId() {
    return Clusters::ScenesManagement::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 : uint8_t {
  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::ScenesManagement::Id;
  }

  chip::GroupId groupID = static_cast<chip::GroupId>(0);

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

  using ResponseType = Clusters::ScenesManagement::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::ScenesManagement::Id;
  }
  static constexpr bool kIsFabricScoped = true;

  chip::GroupId groupID = static_cast<chip::GroupId>(0);

  CHIP_ERROR Decode(TLV::TLVReader &reader, FabricIndex aAccessingFabricIndex);
};
}; // namespace RemoveAllScenes
namespace RemoveAllScenesResponse {
enum class Fields : uint8_t {
  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::ScenesManagement::Id;
  }

  uint8_t status = static_cast<uint8_t>(0);
  chip::GroupId groupID = static_cast<chip::GroupId>(0);

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

  using ResponseType = DataModel::NullObjectType;

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

struct DecodableType {
public:
  static constexpr CommandId GetCommandId() {
    return Commands::RemoveAllScenesResponse::Id;
  }
  static constexpr ClusterId GetClusterId() {
    return Clusters::ScenesManagement::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 : uint8_t {
  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::ScenesManagement::Id;
  }

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);

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

  using ResponseType =
      Clusters::ScenesManagement::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::ScenesManagement::Id;
  }
  static constexpr bool kIsFabricScoped = true;

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);

  CHIP_ERROR Decode(TLV::TLVReader &reader, FabricIndex aAccessingFabricIndex);
};
}; // namespace StoreScene
namespace StoreSceneResponse {
enum class Fields : uint8_t {
  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::ScenesManagement::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(DataModel::FabricAwareTLVWriter &aWriter,
                    TLV::Tag aTag) const;

  using ResponseType = DataModel::NullObjectType;

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

struct DecodableType {
public:
  static constexpr CommandId GetCommandId() {
    return Commands::StoreSceneResponse::Id;
  }
  static constexpr ClusterId GetClusterId() {
    return Clusters::ScenesManagement::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 : uint8_t {
  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::ScenesManagement::Id;
  }

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);
  Optional<DataModel::Nullable<uint32_t>> transitionTime;

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

  using ResponseType = DataModel::NullObjectType;

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

struct DecodableType {
public:
  static constexpr CommandId GetCommandId() {
    return Commands::RecallScene::Id;
  }
  static constexpr ClusterId GetClusterId() {
    return Clusters::ScenesManagement::Id;
  }
  static constexpr bool kIsFabricScoped = true;

  chip::GroupId groupID = static_cast<chip::GroupId>(0);
  uint8_t sceneID = static_cast<uint8_t>(0);
  Optional<DataModel::Nullable<uint32_t>> transitionTime;

  CHIP_ERROR Decode(TLV::TLVReader &reader, FabricIndex aAccessingFabricIndex);
};
}; // namespace RecallScene
namespace GetSceneMembership {
enum class Fields : uint8_t {
  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::ScenesManagement::Id;
  }

  chip::GroupId groupID = static_cast<chip::GroupId>(0);

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

  using ResponseType = Clusters::ScenesManagement::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::ScenesManagement::Id;
  }
  static constexpr bool kIsFabricScoped = true;

  chip::GroupId groupID = static_cast<chip::GroupId>(0);

  CHIP_ERROR Decode(TLV::TLVReader &reader, FabricIndex aAccessingFabricIndex);
};
}; // namespace GetSceneMembership
namespace GetSceneMembershipResponse {
enum class Fields : uint8_t {
  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::ScenesManagement::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(DataModel::FabricAwareTLVWriter &aWriter,
                    TLV::Tag aTag) const;

  using ResponseType = DataModel::NullObjectType;

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

struct DecodableType {
public:
  static constexpr CommandId GetCommandId() {
    return Commands::GetSceneMembershipResponse::Id;
  }
  static constexpr ClusterId GetClusterId() {
    return Clusters::ScenesManagement::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 CopyScene {
enum class Fields : uint8_t {
  kMode = 0,
  kGroupIdentifierFrom = 1,
  kSceneIdentifierFrom = 2,
  kGroupIdentifierTo = 3,
  kSceneIdentifierTo = 4,
};

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

  chip::BitMask<CopyModeBitmap> mode =
      static_cast<chip::BitMask<CopyModeBitmap>>(0);
  chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0);
  uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0);
  chip::GroupId groupIdentifierTo = static_cast<chip::GroupId>(0);
  uint8_t sceneIdentifierTo = static_cast<uint8_t>(0);

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

  using ResponseType =
      Clusters::ScenesManagement::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::ScenesManagement::Id;
  }
  static constexpr bool kIsFabricScoped = true;

  chip::BitMask<CopyModeBitmap> mode =
      static_cast<chip::BitMask<CopyModeBitmap>>(0);
  chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0);
  uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0);
  chip::GroupId groupIdentifierTo = static_cast<chip::GroupId>(0);
  uint8_t sceneIdentifierTo = static_cast<uint8_t>(0);

  CHIP_ERROR Decode(TLV::TLVReader &reader, FabricIndex aAccessingFabricIndex);
};
}; // namespace CopyScene
namespace CopySceneResponse {
enum class Fields : uint8_t {
  kStatus = 0,
  kGroupIdentifierFrom = 1,
  kSceneIdentifierFrom = 2,
};

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

  uint8_t status = static_cast<uint8_t>(0);
  chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0);
  uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0);

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

  using ResponseType = DataModel::NullObjectType;

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

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

  uint8_t status = static_cast<uint8_t>(0);
  chip::GroupId groupIdentifierFrom = static_cast<chip::GroupId>(0);
  uint8_t sceneIdentifierFrom = static_cast<uint8_t>(0);

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