include/vulkan/vulkan_structs.hpp - main - agny/vulkan-headers

include/vulkan/vulkan_structs.hpp
217 474 строки8 MB
Jon Leech
Update for Vulkan-Docs 1.4.352
15 май 2026, 05:57
15 май 2026, 05:57015e25c
// Copyright 2015-2026 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//

// This header is generated from the Khronos Vulkan XML API Registry.

#ifndef VULKAN_STRUCTS_HPP
#define VULKAN_STRUCTS_HPP

// include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private, include "vulkan/vulkan.hpp"

#if !defined( VULKAN_HPP_CXX_MODULE )
#  include <cstring>  // strcmp
#endif

VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
{
  //===============
  //=== STRUCTS ===
  //===============

  // wrapper struct for struct VkAabbPositionsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAabbPositionsKHR.html
  struct AabbPositionsKHR
  {
    using NativeType = VkAabbPositionsKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      AabbPositionsKHR( float minX_ = {}, float minY_ = {}, float minZ_ = {}, float maxX_ = {}, float maxY_ = {}, float maxZ_ = {} ) VULKAN_HPP_NOEXCEPT
      : minX{ minX_ }
      , minY{ minY_ }
      , minZ{ minZ_ }
      , maxX{ maxX_ }
      , maxY{ maxY_ }
      , maxZ{ maxZ_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AabbPositionsKHR( AabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AabbPositionsKHR( VkAabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT : AabbPositionsKHR( *reinterpret_cast<AabbPositionsKHR const *>( &rhs ) ) {}

    AabbPositionsKHR & operator=( AabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AabbPositionsKHR & operator=( VkAabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AabbPositionsKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMinX( float minX_ ) & VULKAN_HPP_NOEXCEPT
    {
      minX = minX_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMinX( float minX_ ) && VULKAN_HPP_NOEXCEPT
    {
      minX = minX_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMinY( float minY_ ) & VULKAN_HPP_NOEXCEPT
    {
      minY = minY_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMinY( float minY_ ) && VULKAN_HPP_NOEXCEPT
    {
      minY = minY_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMinZ( float minZ_ ) & VULKAN_HPP_NOEXCEPT
    {
      minZ = minZ_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMinZ( float minZ_ ) && VULKAN_HPP_NOEXCEPT
    {
      minZ = minZ_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMaxX( float maxX_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxX = maxX_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMaxX( float maxX_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxX = maxX_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMaxY( float maxY_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxY = maxY_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMaxY( float maxY_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxY = maxY_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMaxZ( float maxZ_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxZ = maxZ_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMaxZ( float maxZ_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxZ = maxZ_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAabbPositionsKHR const *>( this );
    }

    operator VkAabbPositionsKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAabbPositionsKHR *>( this );
    }

    operator VkAabbPositionsKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAabbPositionsKHR const *>( this );
    }

    operator VkAabbPositionsKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAabbPositionsKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<float const &, float const &, float const &, float const &, float const &, float const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( minX, minY, minZ, maxX, maxY, maxZ );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AabbPositionsKHR const & ) const = default;
#else
    bool operator==( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( minX == rhs.minX ) && ( minY == rhs.minY ) && ( minZ == rhs.minZ ) && ( maxX == rhs.maxX ) && ( maxY == rhs.maxY ) && ( maxZ == rhs.maxZ );
#  endif
    }

    bool operator!=( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    float minX = {};
    float minY = {};
    float minZ = {};
    float maxX = {};
    float maxY = {};
    float maxZ = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAabbPositionsKHR>
  {
    using Type = AabbPositionsKHR;
  };
#endif
  using AabbPositionsNV = AabbPositionsKHR;

  union DeviceOrHostAddressConstKHR
  {
    using NativeType = VkDeviceOrHostAddressConstKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR( DeviceAddress deviceAddress_ = {} ) : deviceAddress( deviceAddress_ ) {}

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR( void const * hostAddress_ ) : hostAddress( hostAddress_ ) {}
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR & setHostAddress( void const * hostAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      hostAddress = hostAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR && setHostAddress( void const * hostAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      hostAddress = hostAddress_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDeviceOrHostAddressConstKHR const &() const
    {
      return *reinterpret_cast<VkDeviceOrHostAddressConstKHR const *>( this );
    }

    operator VkDeviceOrHostAddressConstKHR &()
    {
      return *reinterpret_cast<VkDeviceOrHostAddressConstKHR *>( this );
    }

#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    DeviceAddress deviceAddress;
    void const *  hostAddress;
#else
    VkDeviceAddress deviceAddress;
    void const *    hostAddress;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDeviceOrHostAddressConstKHR>
  {
    using Type = DeviceOrHostAddressConstKHR;
  };
#endif

  // wrapper struct for struct VkAccelerationStructureGeometryTrianglesDataKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html
  struct AccelerationStructureGeometryTrianglesDataKHR
  {
    using NativeType = VkAccelerationStructureGeometryTrianglesDataKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureGeometryTrianglesDataKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR( Format                      vertexFormat_  = Format::eUndefined,
                                                                           DeviceOrHostAddressConstKHR vertexData_    = {},
                                                                           DeviceSize                  vertexStride_  = {},
                                                                           uint32_t                    maxVertex_     = {},
                                                                           IndexType                   indexType_     = IndexType::eUint16,
                                                                           DeviceOrHostAddressConstKHR indexData_     = {},
                                                                           DeviceOrHostAddressConstKHR transformData_ = {},
                                                                           void const *                pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , vertexFormat{ vertexFormat_ }
      , vertexData{ vertexData_ }
      , vertexStride{ vertexStride_ }
      , maxVertex{ maxVertex_ }
      , indexType{ indexType_ }
      , indexData{ indexData_ }
      , transformData{ transformData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureGeometryTrianglesDataKHR( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureGeometryTrianglesDataKHR( VkAccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureGeometryTrianglesDataKHR( *reinterpret_cast<AccelerationStructureGeometryTrianglesDataKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureGeometryTrianglesDataKHR & operator=( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureGeometryTrianglesDataKHR & operator=( VkAccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureGeometryTrianglesDataKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexStride = vertexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexStride = vertexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setMaxVertex( uint32_t maxVertex_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxVertex = maxVertex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setMaxVertex( uint32_t maxVertex_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxVertex = maxVertex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexData = indexData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indexData = indexData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setTransformData( DeviceOrHostAddressConstKHR const & transformData_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      transformData = transformData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setTransformData( DeviceOrHostAddressConstKHR const & transformData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      transformData = transformData_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryTrianglesDataKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR *>( this );
    }

    operator VkAccelerationStructureGeometryTrianglesDataKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryTrianglesDataKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               Format const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               uint32_t const &,
               IndexType const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceOrHostAddressConstKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData );
    }
#endif

  public:
    StructureType               sType         = StructureType::eAccelerationStructureGeometryTrianglesDataKHR;
    void const *                pNext         = {};
    Format                      vertexFormat  = Format::eUndefined;
    DeviceOrHostAddressConstKHR vertexData    = {};
    DeviceSize                  vertexStride  = {};
    uint32_t                    maxVertex     = {};
    IndexType                   indexType     = IndexType::eUint16;
    DeviceOrHostAddressConstKHR indexData     = {};
    DeviceOrHostAddressConstKHR transformData = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureGeometryTrianglesDataKHR>
  {
    using Type = AccelerationStructureGeometryTrianglesDataKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryTrianglesDataKHR>
  {
    using Type = AccelerationStructureGeometryTrianglesDataKHR;
  };

  // wrapper struct for struct VkAccelerationStructureGeometryAabbsDataKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html
  struct AccelerationStructureGeometryAabbsDataKHR
  {
    using NativeType = VkAccelerationStructureGeometryAabbsDataKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureGeometryAabbsDataKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR( DeviceOrHostAddressConstKHR data_   = {},
                                                                       DeviceSize                  stride_ = {},
                                                                       void const *                pNext_  = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , data{ data_ }
      , stride{ stride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureGeometryAabbsDataKHR( VkAccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureGeometryAabbsDataKHR( *reinterpret_cast<AccelerationStructureGeometryAabbsDataKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureGeometryAabbsDataKHR & operator=( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureGeometryAabbsDataKHR & operator=( VkAccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureGeometryAabbsDataKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR & setData( DeviceOrHostAddressConstKHR const & data_ ) & VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR && setData( DeviceOrHostAddressConstKHR const & data_ ) && VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryAabbsDataKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR *>( this );
    }

    operator VkAccelerationStructureGeometryAabbsDataKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryAabbsDataKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceOrHostAddressConstKHR const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, data, stride );
    }
#endif

  public:
    StructureType               sType  = StructureType::eAccelerationStructureGeometryAabbsDataKHR;
    void const *                pNext  = {};
    DeviceOrHostAddressConstKHR data   = {};
    DeviceSize                  stride = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureGeometryAabbsDataKHR>
  {
    using Type = AccelerationStructureGeometryAabbsDataKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryAabbsDataKHR>
  {
    using Type = AccelerationStructureGeometryAabbsDataKHR;
  };

  // wrapper struct for struct VkAccelerationStructureGeometryInstancesDataKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html
  struct AccelerationStructureGeometryInstancesDataKHR
  {
    using NativeType = VkAccelerationStructureGeometryInstancesDataKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureGeometryInstancesDataKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR( Bool32                      arrayOfPointers_ = {},
                                                                           DeviceOrHostAddressConstKHR data_            = {},
                                                                           void const *                pNext_           = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , arrayOfPointers{ arrayOfPointers_ }
      , data{ data_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureGeometryInstancesDataKHR( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureGeometryInstancesDataKHR( VkAccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureGeometryInstancesDataKHR( *reinterpret_cast<AccelerationStructureGeometryInstancesDataKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureGeometryInstancesDataKHR & operator=( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureGeometryInstancesDataKHR & operator=( VkAccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureGeometryInstancesDataKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR & setArrayOfPointers( Bool32 arrayOfPointers_ ) & VULKAN_HPP_NOEXCEPT
    {
      arrayOfPointers = arrayOfPointers_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR && setArrayOfPointers( Bool32 arrayOfPointers_ ) && VULKAN_HPP_NOEXCEPT
    {
      arrayOfPointers = arrayOfPointers_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR & setData( DeviceOrHostAddressConstKHR const & data_ ) & VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR && setData( DeviceOrHostAddressConstKHR const & data_ ) && VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryInstancesDataKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR *>( this );
    }

    operator VkAccelerationStructureGeometryInstancesDataKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryInstancesDataKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &, DeviceOrHostAddressConstKHR const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, arrayOfPointers, data );
    }
#endif

  public:
    StructureType               sType           = StructureType::eAccelerationStructureGeometryInstancesDataKHR;
    void const *                pNext           = {};
    Bool32                      arrayOfPointers = {};
    DeviceOrHostAddressConstKHR data            = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureGeometryInstancesDataKHR>
  {
    using Type = AccelerationStructureGeometryInstancesDataKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryInstancesDataKHR>
  {
    using Type = AccelerationStructureGeometryInstancesDataKHR;
  };

  union AccelerationStructureGeometryDataKHR
  {
    using NativeType = VkAccelerationStructureGeometryDataKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR( AccelerationStructureGeometryTrianglesDataKHR triangles_ = {} ) : triangles( triangles_ ) {}

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR( AccelerationStructureGeometryAabbsDataKHR aabbs_ ) : aabbs( aabbs_ ) {}

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR( AccelerationStructureGeometryInstancesDataKHR instances_ ) : instances( instances_ ) {}
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR & setTriangles( AccelerationStructureGeometryTrianglesDataKHR const & triangles_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      triangles = triangles_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR && setTriangles( AccelerationStructureGeometryTrianglesDataKHR const & triangles_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      triangles = triangles_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR & setAabbs( AccelerationStructureGeometryAabbsDataKHR const & aabbs_ ) & VULKAN_HPP_NOEXCEPT
    {
      aabbs = aabbs_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR && setAabbs( AccelerationStructureGeometryAabbsDataKHR const & aabbs_ ) && VULKAN_HPP_NOEXCEPT
    {
      aabbs = aabbs_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR & setInstances( AccelerationStructureGeometryInstancesDataKHR const & instances_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      instances = instances_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR && setInstances( AccelerationStructureGeometryInstancesDataKHR const & instances_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      instances = instances_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureGeometryDataKHR const &() const
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryDataKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryDataKHR &()
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryDataKHR *>( this );
    }

#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    AccelerationStructureGeometryTrianglesDataKHR triangles;
    AccelerationStructureGeometryAabbsDataKHR     aabbs;
    AccelerationStructureGeometryInstancesDataKHR instances;
#else
    VkAccelerationStructureGeometryTrianglesDataKHR triangles;
    VkAccelerationStructureGeometryAabbsDataKHR     aabbs;
    VkAccelerationStructureGeometryInstancesDataKHR instances;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureGeometryDataKHR>
  {
    using Type = AccelerationStructureGeometryDataKHR;
  };
#endif

  // wrapper struct for struct VkAccelerationStructureGeometryKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryKHR.html
  struct AccelerationStructureGeometryKHR
  {
    using NativeType = VkAccelerationStructureGeometryKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureGeometryKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR( GeometryTypeKHR                      geometryType_ = GeometryTypeKHR::eTriangles,
                                                              AccelerationStructureGeometryDataKHR geometry_     = {},
                                                              GeometryFlagsKHR                     flags_        = {},
                                                              void const *                         pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , geometryType{ geometryType_ }
      , geometry{ geometry_ }
      , flags{ flags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureGeometryKHR( VkAccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureGeometryKHR( *reinterpret_cast<AccelerationStructureGeometryKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureGeometryKHR & operator=( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureGeometryKHR & operator=( VkAccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureGeometryKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setGeometryType( GeometryTypeKHR geometryType_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometryType = geometryType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setGeometryType( GeometryTypeKHR geometryType_ ) && VULKAN_HPP_NOEXCEPT
    {
      geometryType = geometryType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setGeometry( AccelerationStructureGeometryDataKHR const & geometry_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometry = geometry_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setGeometry( AccelerationStructureGeometryDataKHR const & geometry_ ) && VULKAN_HPP_NOEXCEPT
    {
      geometry = geometry_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setFlags( GeometryFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setFlags( GeometryFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryKHR *>( this );
    }

    operator VkAccelerationStructureGeometryKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, GeometryTypeKHR const &, AccelerationStructureGeometryDataKHR const &, GeometryFlagsKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, geometryType, geometry, flags );
    }
#endif

  public:
    StructureType                        sType        = StructureType::eAccelerationStructureGeometryKHR;
    void const *                         pNext        = {};
    GeometryTypeKHR                      geometryType = GeometryTypeKHR::eTriangles;
    AccelerationStructureGeometryDataKHR geometry     = {};
    GeometryFlagsKHR                     flags        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureGeometryKHR>
  {
    using Type = AccelerationStructureGeometryKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryKHR>
  {
    using Type = AccelerationStructureGeometryKHR;
  };

  union DeviceOrHostAddressKHR
  {
    using NativeType = VkDeviceOrHostAddressKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR( DeviceAddress deviceAddress_ = {} ) : deviceAddress( deviceAddress_ ) {}

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR( void * hostAddress_ ) : hostAddress( hostAddress_ ) {}
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR & setHostAddress( void * hostAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      hostAddress = hostAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR && setHostAddress( void * hostAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      hostAddress = hostAddress_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDeviceOrHostAddressKHR const &() const
    {
      return *reinterpret_cast<VkDeviceOrHostAddressKHR const *>( this );
    }

    operator VkDeviceOrHostAddressKHR &()
    {
      return *reinterpret_cast<VkDeviceOrHostAddressKHR *>( this );
    }

#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    DeviceAddress deviceAddress;
    void *        hostAddress;
#else
    VkDeviceAddress deviceAddress;
    void *          hostAddress;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDeviceOrHostAddressKHR>
  {
    using Type = DeviceOrHostAddressKHR;
  };
#endif

  // wrapper struct for struct VkAccelerationStructureBuildGeometryInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html
  struct AccelerationStructureBuildGeometryInfoKHR
  {
    using NativeType = VkAccelerationStructureBuildGeometryInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureBuildGeometryInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureTypeKHR       type_  = AccelerationStructureTypeKHR::eTopLevel,
                                                                       BuildAccelerationStructureFlagsKHR flags_ = {},
                                                                       BuildAccelerationStructureModeKHR  mode_  = BuildAccelerationStructureModeKHR::eBuild,
                                                                       AccelerationStructureKHR           srcAccelerationStructure_   = {},
                                                                       AccelerationStructureKHR           dstAccelerationStructure_   = {},
                                                                       uint32_t                           geometryCount_              = {},
                                                                       AccelerationStructureGeometryKHR const *         pGeometries_  = {},
                                                                       AccelerationStructureGeometryKHR const * const * ppGeometries_ = {},
                                                                       DeviceOrHostAddressKHR                           scratchData_  = {},
                                                                       void const *                                     pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , type{ type_ }
      , flags{ flags_ }
      , mode{ mode_ }
      , srcAccelerationStructure{ srcAccelerationStructure_ }
      , dstAccelerationStructure{ dstAccelerationStructure_ }
      , geometryCount{ geometryCount_ }
      , pGeometries{ pGeometries_ }
      , ppGeometries{ ppGeometries_ }
      , scratchData{ scratchData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureBuildGeometryInfoKHR( VkAccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureBuildGeometryInfoKHR( *reinterpret_cast<AccelerationStructureBuildGeometryInfoKHR const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureTypeKHR                                                    type_,
                                               BuildAccelerationStructureFlagsKHR                                              flags_,
                                               BuildAccelerationStructureModeKHR                                               mode_,
                                               AccelerationStructureKHR                                                        srcAccelerationStructure_,
                                               AccelerationStructureKHR                                                        dstAccelerationStructure_,
                                               ArrayProxyNoTemporaries<AccelerationStructureGeometryKHR const> const &         geometries_,
                                               ArrayProxyNoTemporaries<AccelerationStructureGeometryKHR const * const> const & pGeometries_ = {},
                                               DeviceOrHostAddressKHR                                                          scratchData_ = {},
                                               void const *                                                                    pNext_       = nullptr )
      : pNext( pNext_ )
      , type( type_ )
      , flags( flags_ )
      , mode( mode_ )
      , srcAccelerationStructure( srcAccelerationStructure_ )
      , dstAccelerationStructure( dstAccelerationStructure_ )
      , geometryCount( static_cast<uint32_t>( !geometries_.empty() ? geometries_.size() : pGeometries_.size() ) )
      , pGeometries( geometries_.data() )
      , ppGeometries( pGeometries_.data() )
      , scratchData( scratchData_ )
    {
#    ifdef VULKAN_HPP_NO_EXCEPTIONS
      VULKAN_HPP_ASSERT( ( !geometries_.empty() + !pGeometries_.empty() ) <= 1 );
#    else
      if ( 1 < ( !geometries_.empty() + !pGeometries_.empty() ) )
      {
        throw LogicError(
          VULKAN_HPP_NAMESPACE_STRING
          "::AccelerationStructureBuildGeometryInfoKHR::AccelerationStructureBuildGeometryInfoKHR: 1 < ( !geometries_.empty() + !pGeometries_.empty() )" );
      }
#    endif /*VULKAN_HPP_NO_EXCEPTIONS*/
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    AccelerationStructureBuildGeometryInfoKHR & operator=( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureBuildGeometryInfoKHR & operator=( VkAccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureBuildGeometryInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setType( AccelerationStructureTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setType( AccelerationStructureTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setMode( BuildAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setMode( BuildAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setSrcAccelerationStructure( AccelerationStructureKHR srcAccelerationStructure_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      srcAccelerationStructure = srcAccelerationStructure_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setSrcAccelerationStructure( AccelerationStructureKHR srcAccelerationStructure_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      srcAccelerationStructure = srcAccelerationStructure_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setDstAccelerationStructure( AccelerationStructureKHR dstAccelerationStructure_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      dstAccelerationStructure = dstAccelerationStructure_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setDstAccelerationStructure( AccelerationStructureKHR dstAccelerationStructure_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      dstAccelerationStructure = dstAccelerationStructure_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setGeometryCount( uint32_t geometryCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometryCount = geometryCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setGeometryCount( uint32_t geometryCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      geometryCount = geometryCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setPGeometries( AccelerationStructureGeometryKHR const * pGeometries_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pGeometries = pGeometries_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setPGeometries( AccelerationStructureGeometryKHR const * pGeometries_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pGeometries = pGeometries_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureBuildGeometryInfoKHR &
      setGeometries( ArrayProxyNoTemporaries<AccelerationStructureGeometryKHR const> const & geometries_ ) VULKAN_HPP_NOEXCEPT
    {
      geometryCount = static_cast<uint32_t>( geometries_.size() );
      pGeometries   = geometries_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setPpGeometries( AccelerationStructureGeometryKHR const * const * ppGeometries_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      ppGeometries = ppGeometries_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setPpGeometries( AccelerationStructureGeometryKHR const * const * ppGeometries_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      ppGeometries = ppGeometries_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureBuildGeometryInfoKHR &
      setPGeometries( ArrayProxyNoTemporaries<AccelerationStructureGeometryKHR const * const> const & pGeometries_ ) VULKAN_HPP_NOEXCEPT
    {
      geometryCount = static_cast<uint32_t>( pGeometries_.size() );
      ppGeometries  = pGeometries_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) & VULKAN_HPP_NOEXCEPT
    {
      scratchData = scratchData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) && VULKAN_HPP_NOEXCEPT
    {
      scratchData = scratchData_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR const *>( this );
    }

    operator VkAccelerationStructureBuildGeometryInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR *>( this );
    }

    operator VkAccelerationStructureBuildGeometryInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR const *>( this );
    }

    operator VkAccelerationStructureBuildGeometryInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AccelerationStructureTypeKHR const &,
               BuildAccelerationStructureFlagsKHR const &,
               BuildAccelerationStructureModeKHR const &,
               AccelerationStructureKHR const &,
               AccelerationStructureKHR const &,
               uint32_t const &,
               AccelerationStructureGeometryKHR const * const &,
               AccelerationStructureGeometryKHR const * const * const &,
               DeviceOrHostAddressKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie(
        sType, pNext, type, flags, mode, srcAccelerationStructure, dstAccelerationStructure, geometryCount, pGeometries, ppGeometries, scratchData );
    }
#endif

  public:
    StructureType                                    sType                    = StructureType::eAccelerationStructureBuildGeometryInfoKHR;
    void const *                                     pNext                    = {};
    AccelerationStructureTypeKHR                     type                     = AccelerationStructureTypeKHR::eTopLevel;
    BuildAccelerationStructureFlagsKHR               flags                    = {};
    BuildAccelerationStructureModeKHR                mode                     = BuildAccelerationStructureModeKHR::eBuild;
    AccelerationStructureKHR                         srcAccelerationStructure = {};
    AccelerationStructureKHR                         dstAccelerationStructure = {};
    uint32_t                                         geometryCount            = {};
    AccelerationStructureGeometryKHR const *         pGeometries              = {};
    AccelerationStructureGeometryKHR const * const * ppGeometries             = {};
    DeviceOrHostAddressKHR                           scratchData              = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureBuildGeometryInfoKHR>
  {
    using Type = AccelerationStructureBuildGeometryInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureBuildGeometryInfoKHR>
  {
    using Type = AccelerationStructureBuildGeometryInfoKHR;
  };

  // wrapper struct for struct VkAccelerationStructureBuildRangeInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildRangeInfoKHR.html
  struct AccelerationStructureBuildRangeInfoKHR
  {
    using NativeType = VkAccelerationStructureBuildRangeInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureBuildRangeInfoKHR( uint32_t primitiveCount_  = {},
                                                                 uint32_t primitiveOffset_ = {},
                                                                 uint32_t firstVertex_     = {},
                                                                 uint32_t transformOffset_ = {} ) VULKAN_HPP_NOEXCEPT
      : primitiveCount{ primitiveCount_ }
      , primitiveOffset{ primitiveOffset_ }
      , firstVertex{ firstVertex_ }
      , transformOffset{ transformOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureBuildRangeInfoKHR( AccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureBuildRangeInfoKHR( VkAccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureBuildRangeInfoKHR( *reinterpret_cast<AccelerationStructureBuildRangeInfoKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureBuildRangeInfoKHR & operator=( AccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureBuildRangeInfoKHR & operator=( VkAccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureBuildRangeInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setPrimitiveCount( uint32_t primitiveCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      primitiveCount = primitiveCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setPrimitiveCount( uint32_t primitiveCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      primitiveCount = primitiveCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setPrimitiveOffset( uint32_t primitiveOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      primitiveOffset = primitiveOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setPrimitiveOffset( uint32_t primitiveOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      primitiveOffset = primitiveOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setFirstVertex( uint32_t firstVertex_ ) & VULKAN_HPP_NOEXCEPT
    {
      firstVertex = firstVertex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setFirstVertex( uint32_t firstVertex_ ) && VULKAN_HPP_NOEXCEPT
    {
      firstVertex = firstVertex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setTransformOffset( uint32_t transformOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      transformOffset = transformOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setTransformOffset( uint32_t transformOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      transformOffset = transformOffset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureBuildRangeInfoKHR const *>( this );
    }

    operator VkAccelerationStructureBuildRangeInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureBuildRangeInfoKHR *>( this );
    }

    operator VkAccelerationStructureBuildRangeInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureBuildRangeInfoKHR const *>( this );
    }

    operator VkAccelerationStructureBuildRangeInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureBuildRangeInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( primitiveCount, primitiveOffset, firstVertex, transformOffset );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureBuildRangeInfoKHR const & ) const = default;
#else
    bool operator==( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( primitiveCount == rhs.primitiveCount ) && ( primitiveOffset == rhs.primitiveOffset ) && ( firstVertex == rhs.firstVertex ) &&
             ( transformOffset == rhs.transformOffset );
#  endif
    }

    bool operator!=( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t primitiveCount  = {};
    uint32_t primitiveOffset = {};
    uint32_t firstVertex     = {};
    uint32_t transformOffset = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureBuildRangeInfoKHR>
  {
    using Type = AccelerationStructureBuildRangeInfoKHR;
  };
#endif

  // wrapper struct for struct VkAccelerationStructureBuildSizesInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildSizesInfoKHR.html
  struct AccelerationStructureBuildSizesInfoKHR
  {
    using NativeType = VkAccelerationStructureBuildSizesInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureBuildSizesInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureBuildSizesInfoKHR( DeviceSize accelerationStructureSize_ = {},
                                                                 DeviceSize updateScratchSize_         = {},
                                                                 DeviceSize buildScratchSize_          = {},
                                                                 void *     pNext_                     = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , accelerationStructureSize{ accelerationStructureSize_ }
      , updateScratchSize{ updateScratchSize_ }
      , buildScratchSize{ buildScratchSize_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureBuildSizesInfoKHR( AccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureBuildSizesInfoKHR( VkAccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureBuildSizesInfoKHR( *reinterpret_cast<AccelerationStructureBuildSizesInfoKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureBuildSizesInfoKHR & operator=( AccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureBuildSizesInfoKHR & operator=( VkAccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureBuildSizesInfoKHR const *>( &rhs );
      return *this;
    }

    operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR const *>( this );
    }

    operator VkAccelerationStructureBuildSizesInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( this );
    }

    operator VkAccelerationStructureBuildSizesInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR const *>( this );
    }

    operator VkAccelerationStructureBuildSizesInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, DeviceSize const &, DeviceSize const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureBuildSizesInfoKHR const & ) const = default;
#else
    bool operator==( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureSize == rhs.accelerationStructureSize ) &&
             ( updateScratchSize == rhs.updateScratchSize ) && ( buildScratchSize == rhs.buildScratchSize );
#  endif
    }

    bool operator!=( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                     = StructureType::eAccelerationStructureBuildSizesInfoKHR;
    void *        pNext                     = {};
    DeviceSize    accelerationStructureSize = {};
    DeviceSize    updateScratchSize         = {};
    DeviceSize    buildScratchSize          = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureBuildSizesInfoKHR>
  {
    using Type = AccelerationStructureBuildSizesInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureBuildSizesInfoKHR>
  {
    using Type = AccelerationStructureBuildSizesInfoKHR;
  };

  // wrapper struct for struct VkAccelerationStructureCaptureDescriptorDataInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCaptureDescriptorDataInfoEXT.html
  struct AccelerationStructureCaptureDescriptorDataInfoEXT
  {
    using NativeType = VkAccelerationStructureCaptureDescriptorDataInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureCaptureDescriptorDataInfoEXT( AccelerationStructureKHR accelerationStructure_   = {},
                                                                            AccelerationStructureNV  accelerationStructureNV_ = {},
                                                                            void const *             pNext_                   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , accelerationStructure{ accelerationStructure_ }
      , accelerationStructureNV{ accelerationStructureNV_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      AccelerationStructureCaptureDescriptorDataInfoEXT( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureCaptureDescriptorDataInfoEXT( VkAccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureCaptureDescriptorDataInfoEXT( *reinterpret_cast<AccelerationStructureCaptureDescriptorDataInfoEXT const *>( &rhs ) )
    {
    }

    AccelerationStructureCaptureDescriptorDataInfoEXT &
      operator=( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureCaptureDescriptorDataInfoEXT & operator=( VkAccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureCaptureDescriptorDataInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT & setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT && setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT & setAccelerationStructureNV( AccelerationStructureNV accelerationStructureNV_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructureNV = accelerationStructureNV_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT &&
      setAccelerationStructureNV( AccelerationStructureNV accelerationStructureNV_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructureNV = accelerationStructureNV_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureCaptureDescriptorDataInfoEXT const *>( this );
    }

    operator VkAccelerationStructureCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureCaptureDescriptorDataInfoEXT *>( this );
    }

    operator VkAccelerationStructureCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureCaptureDescriptorDataInfoEXT const *>( this );
    }

    operator VkAccelerationStructureCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureCaptureDescriptorDataInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, AccelerationStructureKHR const &, AccelerationStructureNV const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, accelerationStructure, accelerationStructureNV );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureCaptureDescriptorDataInfoEXT const & ) const = default;
#else
    bool operator==( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) &&
             ( accelerationStructureNV == rhs.accelerationStructureNV );
#  endif
    }

    bool operator!=( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType            sType                   = StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT;
    void const *             pNext                   = {};
    AccelerationStructureKHR accelerationStructure   = {};
    AccelerationStructureNV  accelerationStructureNV = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureCaptureDescriptorDataInfoEXT>
  {
    using Type = AccelerationStructureCaptureDescriptorDataInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT>
  {
    using Type = AccelerationStructureCaptureDescriptorDataInfoEXT;
  };

  // wrapper struct for struct VkDeviceAddressRangeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressRangeKHR.html
  struct DeviceAddressRangeKHR
  {
    using NativeType = VkDeviceAddressRangeKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DeviceAddressRangeKHR( DeviceAddress address_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
      : address{ address_ }
      , size{ size_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DeviceAddressRangeKHR( DeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DeviceAddressRangeKHR( VkDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : DeviceAddressRangeKHR( *reinterpret_cast<DeviceAddressRangeKHR const *>( &rhs ) )
    {
    }

    DeviceAddressRangeKHR & operator=( DeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DeviceAddressRangeKHR & operator=( VkDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DeviceAddressRangeKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeKHR & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT
    {
      address = address_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeKHR && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT
    {
      address = address_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDeviceAddressRangeKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceAddressRangeKHR const *>( this );
    }

    operator VkDeviceAddressRangeKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceAddressRangeKHR *>( this );
    }

    operator VkDeviceAddressRangeKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceAddressRangeKHR const *>( this );
    }

    operator VkDeviceAddressRangeKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceAddressRangeKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( address, size );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DeviceAddressRangeKHR const & ) const = default;
#else
    bool operator==( DeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( address == rhs.address ) && ( size == rhs.size );
#  endif
    }

    bool operator!=( DeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress address = {};
    DeviceSize    size    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDeviceAddressRangeKHR>
  {
    using Type = DeviceAddressRangeKHR;
  };
#endif
  using DeviceAddressRangeEXT = DeviceAddressRangeKHR;

  // wrapper struct for struct VkAccelerationStructureCreateInfo2KHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfo2KHR.html
  struct AccelerationStructureCreateInfo2KHR
  {
    using NativeType = VkAccelerationStructureCreateInfo2KHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureCreateInfo2KHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfo2KHR( AccelerationStructureCreateFlagsKHR createFlags_  = {},
                                                              DeviceAddressRangeKHR               addressRange_ = {},
                                                              AddressCommandFlagsKHR              addressFlags_ = {},
                                                              AccelerationStructureTypeKHR        type_         = AccelerationStructureTypeKHR::eTopLevel,
                                                              void const *                        pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , createFlags{ createFlags_ }
      , addressRange{ addressRange_ }
      , addressFlags{ addressFlags_ }
      , type{ type_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfo2KHR( AccelerationStructureCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureCreateInfo2KHR( VkAccelerationStructureCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureCreateInfo2KHR( *reinterpret_cast<AccelerationStructureCreateInfo2KHR const *>( &rhs ) )
    {
    }

    AccelerationStructureCreateInfo2KHR & operator=( AccelerationStructureCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureCreateInfo2KHR & operator=( VkAccelerationStructureCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureCreateInfo2KHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      createFlags = createFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      createFlags = createFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setType( AccelerationStructureTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setType( AccelerationStructureTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureCreateInfo2KHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureCreateInfo2KHR const *>( this );
    }

    operator VkAccelerationStructureCreateInfo2KHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureCreateInfo2KHR *>( this );
    }

    operator VkAccelerationStructureCreateInfo2KHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureCreateInfo2KHR const *>( this );
    }

    operator VkAccelerationStructureCreateInfo2KHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureCreateInfo2KHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AccelerationStructureCreateFlagsKHR const &,
               DeviceAddressRangeKHR const &,
               AddressCommandFlagsKHR const &,
               AccelerationStructureTypeKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, createFlags, addressRange, addressFlags, type );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureCreateInfo2KHR const & ) const = default;
#else
    bool operator==( AccelerationStructureCreateInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && ( addressRange == rhs.addressRange ) &&
             ( addressFlags == rhs.addressFlags ) && ( type == rhs.type );
#  endif
    }

    bool operator!=( AccelerationStructureCreateInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                       sType        = StructureType::eAccelerationStructureCreateInfo2KHR;
    void const *                        pNext        = {};
    AccelerationStructureCreateFlagsKHR createFlags  = {};
    DeviceAddressRangeKHR               addressRange = {};
    AddressCommandFlagsKHR              addressFlags = {};
    AccelerationStructureTypeKHR        type         = AccelerationStructureTypeKHR::eTopLevel;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureCreateInfo2KHR>
  {
    using Type = AccelerationStructureCreateInfo2KHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureCreateInfo2KHR>
  {
    using Type = AccelerationStructureCreateInfo2KHR;
  };

  // wrapper struct for struct VkAccelerationStructureCreateInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfoKHR.html
  struct AccelerationStructureCreateInfoKHR
  {
    using NativeType = VkAccelerationStructureCreateInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureCreateInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( AccelerationStructureCreateFlagsKHR createFlags_   = {},
                                                             Buffer                              buffer_        = {},
                                                             DeviceSize                          offset_        = {},
                                                             DeviceSize                          size_          = {},
                                                             AccelerationStructureTypeKHR        type_          = AccelerationStructureTypeKHR::eTopLevel,
                                                             DeviceAddress                       deviceAddress_ = {},
                                                             void const *                        pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , createFlags{ createFlags_ }
      , buffer{ buffer_ }
      , offset{ offset_ }
      , size{ size_ }
      , type{ type_ }
      , deviceAddress{ deviceAddress_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureCreateInfoKHR( VkAccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureCreateInfoKHR( *reinterpret_cast<AccelerationStructureCreateInfoKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureCreateInfoKHR & operator=( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureCreateInfoKHR & operator=( VkAccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureCreateInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      createFlags = createFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      createFlags = createFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setType( AccelerationStructureTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setType( AccelerationStructureTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureCreateInfoKHR const *>( this );
    }

    operator VkAccelerationStructureCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureCreateInfoKHR *>( this );
    }

    operator VkAccelerationStructureCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureCreateInfoKHR const *>( this );
    }

    operator VkAccelerationStructureCreateInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureCreateInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AccelerationStructureCreateFlagsKHR const &,
               Buffer const &,
               DeviceSize const &,
               DeviceSize const &,
               AccelerationStructureTypeKHR const &,
               DeviceAddress const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureCreateInfoKHR const & ) const = default;
#else
    bool operator==( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) &&
             ( size == rhs.size ) && ( type == rhs.type ) && ( deviceAddress == rhs.deviceAddress );
#  endif
    }

    bool operator!=( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                       sType         = StructureType::eAccelerationStructureCreateInfoKHR;
    void const *                        pNext         = {};
    AccelerationStructureCreateFlagsKHR createFlags   = {};
    Buffer                              buffer        = {};
    DeviceSize                          offset        = {};
    DeviceSize                          size          = {};
    AccelerationStructureTypeKHR        type          = AccelerationStructureTypeKHR::eTopLevel;
    DeviceAddress                       deviceAddress = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureCreateInfoKHR>
  {
    using Type = AccelerationStructureCreateInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureCreateInfoKHR>
  {
    using Type = AccelerationStructureCreateInfoKHR;
  };

  // wrapper struct for struct VkGeometryTrianglesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryTrianglesNV.html
  struct GeometryTrianglesNV
  {
    using NativeType = VkGeometryTrianglesNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eGeometryTrianglesNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( Buffer       vertexData_      = {},
                                              DeviceSize   vertexOffset_    = {},
                                              uint32_t     vertexCount_     = {},
                                              DeviceSize   vertexStride_    = {},
                                              Format       vertexFormat_    = Format::eUndefined,
                                              Buffer       indexData_       = {},
                                              DeviceSize   indexOffset_     = {},
                                              uint32_t     indexCount_      = {},
                                              IndexType    indexType_       = IndexType::eUint16,
                                              Buffer       transformData_   = {},
                                              DeviceSize   transformOffset_ = {},
                                              void const * pNext_           = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , vertexData{ vertexData_ }
      , vertexOffset{ vertexOffset_ }
      , vertexCount{ vertexCount_ }
      , vertexStride{ vertexStride_ }
      , vertexFormat{ vertexFormat_ }
      , indexData{ indexData_ }
      , indexOffset{ indexOffset_ }
      , indexCount{ indexCount_ }
      , indexType{ indexType_ }
      , transformData{ transformData_ }
      , transformOffset{ transformOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryTrianglesNV( *reinterpret_cast<GeometryTrianglesNV const *>( &rhs ) )
    {
    }

    GeometryTrianglesNV & operator=( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    GeometryTrianglesNV & operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<GeometryTrianglesNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexData( Buffer vertexData_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexData( Buffer vertexData_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexOffset( DeviceSize vertexOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexOffset = vertexOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexOffset( DeviceSize vertexOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexOffset = vertexOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexCount = vertexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexCount = vertexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexStride = vertexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexStride = vertexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexData( Buffer indexData_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexData = indexData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexData( Buffer indexData_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexData = indexData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexOffset( DeviceSize indexOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexOffset = indexOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexOffset( DeviceSize indexOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexOffset = indexOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexCount( uint32_t indexCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexCount = indexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexCount( uint32_t indexCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexCount = indexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setTransformData( Buffer transformData_ ) & VULKAN_HPP_NOEXCEPT
    {
      transformData = transformData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setTransformData( Buffer transformData_ ) && VULKAN_HPP_NOEXCEPT
    {
      transformData = transformData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setTransformOffset( DeviceSize transformOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      transformOffset = transformOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setTransformOffset( DeviceSize transformOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      transformOffset = transformOffset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkGeometryTrianglesNV const *>( this );
    }

    operator VkGeometryTrianglesNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkGeometryTrianglesNV *>( this );
    }

    operator VkGeometryTrianglesNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkGeometryTrianglesNV const *>( this );
    }

    operator VkGeometryTrianglesNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkGeometryTrianglesNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               Buffer const &,
               DeviceSize const &,
               uint32_t const &,
               DeviceSize const &,
               Format const &,
               Buffer const &,
               DeviceSize const &,
               uint32_t const &,
               IndexType const &,
               Buffer const &,
               DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       vertexData,
                       vertexOffset,
                       vertexCount,
                       vertexStride,
                       vertexFormat,
                       indexData,
                       indexOffset,
                       indexCount,
                       indexType,
                       transformData,
                       transformOffset );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( GeometryTrianglesNV const & ) const = default;
#else
    bool operator==( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexData == rhs.vertexData ) && ( vertexOffset == rhs.vertexOffset ) &&
             ( vertexCount == rhs.vertexCount ) && ( vertexStride == rhs.vertexStride ) && ( vertexFormat == rhs.vertexFormat ) &&
             ( indexData == rhs.indexData ) && ( indexOffset == rhs.indexOffset ) && ( indexCount == rhs.indexCount ) && ( indexType == rhs.indexType ) &&
             ( transformData == rhs.transformData ) && ( transformOffset == rhs.transformOffset );
#  endif
    }

    bool operator!=( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType           = StructureType::eGeometryTrianglesNV;
    void const *  pNext           = {};
    Buffer        vertexData      = {};
    DeviceSize    vertexOffset    = {};
    uint32_t      vertexCount     = {};
    DeviceSize    vertexStride    = {};
    Format        vertexFormat    = Format::eUndefined;
    Buffer        indexData       = {};
    DeviceSize    indexOffset     = {};
    uint32_t      indexCount      = {};
    IndexType     indexType       = IndexType::eUint16;
    Buffer        transformData   = {};
    DeviceSize    transformOffset = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkGeometryTrianglesNV>
  {
    using Type = GeometryTrianglesNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eGeometryTrianglesNV>
  {
    using Type = GeometryTrianglesNV;
  };

  // wrapper struct for struct VkGeometryAABBNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryAABBNV.html
  struct GeometryAABBNV
  {
    using NativeType = VkGeometryAABBNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eGeometryAabbNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR GeometryAABBNV(
      Buffer aabbData_ = {}, uint32_t numAABBs_ = {}, uint32_t stride_ = {}, DeviceSize offset_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , aabbData{ aabbData_ }
      , numAABBs{ numAABBs_ }
      , stride{ stride_ }
      , offset{ offset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR GeometryAABBNV( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryAABBNV( *reinterpret_cast<GeometryAABBNV const *>( &rhs ) ) {}

    GeometryAABBNV & operator=( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    GeometryAABBNV & operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<GeometryAABBNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setAabbData( Buffer aabbData_ ) & VULKAN_HPP_NOEXCEPT
    {
      aabbData = aabbData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setAabbData( Buffer aabbData_ ) && VULKAN_HPP_NOEXCEPT
    {
      aabbData = aabbData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setNumAABBs( uint32_t numAABBs_ ) & VULKAN_HPP_NOEXCEPT
    {
      numAABBs = numAABBs_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setNumAABBs( uint32_t numAABBs_ ) && VULKAN_HPP_NOEXCEPT
    {
      numAABBs = numAABBs_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkGeometryAABBNV const *>( this );
    }

    operator VkGeometryAABBNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkGeometryAABBNV *>( this );
    }

    operator VkGeometryAABBNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkGeometryAABBNV const *>( this );
    }

    operator VkGeometryAABBNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkGeometryAABBNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Buffer const &, uint32_t const &, uint32_t const &, DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, aabbData, numAABBs, stride, offset );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( GeometryAABBNV const & ) const = default;
#else
    bool operator==( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) && ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) &&
             ( offset == rhs.offset );
#  endif
    }

    bool operator!=( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType    = StructureType::eGeometryAabbNV;
    void const *  pNext    = {};
    Buffer        aabbData = {};
    uint32_t      numAABBs = {};
    uint32_t      stride   = {};
    DeviceSize    offset   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkGeometryAABBNV>
  {
    using Type = GeometryAABBNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eGeometryAabbNV>
  {
    using Type = GeometryAABBNV;
  };

  // wrapper struct for struct VkGeometryDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryDataNV.html
  struct GeometryDataNV
  {
    using NativeType = VkGeometryDataNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR GeometryDataNV( GeometryTrianglesNV triangles_ = {}, GeometryAABBNV aabbs_ = {} ) VULKAN_HPP_NOEXCEPT
      : triangles{ triangles_ }
      , aabbs{ aabbs_ }
    {
    }

    VULKAN_HPP_CONSTEXPR GeometryDataNV( GeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    GeometryDataNV( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryDataNV( *reinterpret_cast<GeometryDataNV const *>( &rhs ) ) {}

    GeometryDataNV & operator=( GeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    GeometryDataNV & operator=( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<GeometryDataNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 GeometryDataNV & setTriangles( GeometryTrianglesNV const & triangles_ ) & VULKAN_HPP_NOEXCEPT
    {
      triangles = triangles_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryDataNV && setTriangles( GeometryTrianglesNV const & triangles_ ) && VULKAN_HPP_NOEXCEPT
    {
      triangles = triangles_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryDataNV & setAabbs( GeometryAABBNV const & aabbs_ ) & VULKAN_HPP_NOEXCEPT
    {
      aabbs = aabbs_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryDataNV && setAabbs( GeometryAABBNV const & aabbs_ ) && VULKAN_HPP_NOEXCEPT
    {
      aabbs = aabbs_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkGeometryDataNV const *>( this );
    }

    operator VkGeometryDataNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkGeometryDataNV *>( this );
    }

    operator VkGeometryDataNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkGeometryDataNV const *>( this );
    }

    operator VkGeometryDataNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkGeometryDataNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<GeometryTrianglesNV const &, GeometryAABBNV const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( triangles, aabbs );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( GeometryDataNV const & ) const = default;
#else
    bool operator==( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs );
#  endif
    }

    bool operator!=( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    GeometryTrianglesNV triangles = {};
    GeometryAABBNV      aabbs     = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkGeometryDataNV>
  {
    using Type = GeometryDataNV;
  };
#endif

  // wrapper struct for struct VkGeometryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryNV.html
  struct GeometryNV
  {
    using NativeType = VkGeometryNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eGeometryNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR GeometryNV( GeometryTypeKHR  geometryType_ = GeometryTypeKHR::eTriangles,
                                     GeometryDataNV   geometry_     = {},
                                     GeometryFlagsKHR flags_        = {},
                                     void const *     pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , geometryType{ geometryType_ }
      , geometry{ geometry_ }
      , flags{ flags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR GeometryNV( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryNV( *reinterpret_cast<GeometryNV const *>( &rhs ) ) {}

    GeometryNV & operator=( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    GeometryNV & operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<GeometryNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 GeometryNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryNV & setGeometryType( GeometryTypeKHR geometryType_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometryType = geometryType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryNV && setGeometryType( GeometryTypeKHR geometryType_ ) && VULKAN_HPP_NOEXCEPT
    {
      geometryType = geometryType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryNV & setGeometry( GeometryDataNV const & geometry_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometry = geometry_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryNV && setGeometry( GeometryDataNV const & geometry_ ) && VULKAN_HPP_NOEXCEPT
    {
      geometry = geometry_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryNV & setFlags( GeometryFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 GeometryNV && setFlags( GeometryFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkGeometryNV const *>( this );
    }

    operator VkGeometryNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkGeometryNV *>( this );
    }

    operator VkGeometryNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkGeometryNV const *>( this );
    }

    operator VkGeometryNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkGeometryNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, GeometryTypeKHR const &, GeometryDataNV const &, GeometryFlagsKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, geometryType, geometry, flags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( GeometryNV const & ) const = default;
#else
    bool operator==( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) && ( geometry == rhs.geometry ) && ( flags == rhs.flags );
#  endif
    }

    bool operator!=( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType        = StructureType::eGeometryNV;
    void const *     pNext        = {};
    GeometryTypeKHR  geometryType = GeometryTypeKHR::eTriangles;
    GeometryDataNV   geometry     = {};
    GeometryFlagsKHR flags        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkGeometryNV>
  {
    using Type = GeometryNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eGeometryNV>
  {
    using Type = GeometryNV;
  };

  // wrapper struct for struct VkAccelerationStructureInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureInfoNV.html
  struct AccelerationStructureInfoNV
  {
    using NativeType = VkAccelerationStructureInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( AccelerationStructureTypeNV        type_          = {},
                                                      BuildAccelerationStructureFlagsKHR flags_         = {},
                                                      uint32_t                           instanceCount_ = {},
                                                      uint32_t                           geometryCount_ = {},
                                                      GeometryNV const *                 pGeometries_   = {},
                                                      void const *                       pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , type{ type_ }
      , flags{ flags_ }
      , instanceCount{ instanceCount_ }
      , geometryCount{ geometryCount_ }
      , pGeometries{ pGeometries_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureInfoNV( *reinterpret_cast<AccelerationStructureInfoNV const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureInfoNV( AccelerationStructureTypeNV                       type_,
                                 BuildAccelerationStructureFlagsKHR                flags_,
                                 uint32_t                                          instanceCount_,
                                 ArrayProxyNoTemporaries<GeometryNV const> const & geometries_,
                                 void const *                                      pNext_ = nullptr )
      : pNext( pNext_ )
      , type( type_ )
      , flags( flags_ )
      , instanceCount( instanceCount_ )
      , geometryCount( static_cast<uint32_t>( geometries_.size() ) )
      , pGeometries( geometries_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    AccelerationStructureInfoNV & operator=( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureInfoNV & operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setType( AccelerationStructureTypeNV type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setType( AccelerationStructureTypeNV type_ ) && VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      instanceCount = instanceCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      instanceCount = instanceCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setGeometryCount( uint32_t geometryCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometryCount = geometryCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setGeometryCount( uint32_t geometryCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      geometryCount = geometryCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setPGeometries( GeometryNV const * pGeometries_ ) & VULKAN_HPP_NOEXCEPT
    {
      pGeometries = pGeometries_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setPGeometries( GeometryNV const * pGeometries_ ) && VULKAN_HPP_NOEXCEPT
    {
      pGeometries = pGeometries_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureInfoNV & setGeometries( ArrayProxyNoTemporaries<GeometryNV const> const & geometries_ ) VULKAN_HPP_NOEXCEPT
    {
      geometryCount = static_cast<uint32_t>( geometries_.size() );
      pGeometries   = geometries_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureInfoNV const *>( this );
    }

    operator VkAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureInfoNV *>( this );
    }

    operator VkAccelerationStructureInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureInfoNV const *>( this );
    }

    operator VkAccelerationStructureInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AccelerationStructureTypeNV const &,
               BuildAccelerationStructureFlagsKHR const &,
               uint32_t const &,
               uint32_t const &,
               GeometryNV const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureInfoNV const & ) const = default;
#else
    bool operator==( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) && ( instanceCount == rhs.instanceCount ) &&
             ( geometryCount == rhs.geometryCount ) && ( pGeometries == rhs.pGeometries );
#  endif
    }

    bool operator!=( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                      sType         = StructureType::eAccelerationStructureInfoNV;
    void const *                       pNext         = {};
    AccelerationStructureTypeNV        type          = {};
    BuildAccelerationStructureFlagsKHR flags         = {};
    uint32_t                           instanceCount = {};
    uint32_t                           geometryCount = {};
    GeometryNV const *                 pGeometries   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureInfoNV>
  {
    using Type = AccelerationStructureInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureInfoNV>
  {
    using Type = AccelerationStructureInfoNV;
  };

  // wrapper struct for struct VkAccelerationStructureCreateInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfoNV.html
  struct AccelerationStructureCreateInfoNV
  {
    using NativeType = VkAccelerationStructureCreateInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureCreateInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( DeviceSize                  compactedSize_ = {},
                                                            AccelerationStructureInfoNV info_          = {},
                                                            void const *                pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , compactedSize{ compactedSize_ }
      , info{ info_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureCreateInfoNV( *reinterpret_cast<AccelerationStructureCreateInfoNV const *>( &rhs ) )
    {
    }

    AccelerationStructureCreateInfoNV & operator=( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureCreateInfoNV & operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureCreateInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV & setCompactedSize( DeviceSize compactedSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      compactedSize = compactedSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV && setCompactedSize( DeviceSize compactedSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      compactedSize = compactedSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV & setInfo( AccelerationStructureInfoNV const & info_ ) & VULKAN_HPP_NOEXCEPT
    {
      info = info_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV && setInfo( AccelerationStructureInfoNV const & info_ ) && VULKAN_HPP_NOEXCEPT
    {
      info = info_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureCreateInfoNV const *>( this );
    }

    operator VkAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureCreateInfoNV *>( this );
    }

    operator VkAccelerationStructureCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureCreateInfoNV const *>( this );
    }

    operator VkAccelerationStructureCreateInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureCreateInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceSize const &, AccelerationStructureInfoNV const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, compactedSize, info );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureCreateInfoNV const & ) const = default;
#else
    bool operator==( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) && ( info == rhs.info );
#  endif
    }

    bool operator!=( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType               sType         = StructureType::eAccelerationStructureCreateInfoNV;
    void const *                pNext         = {};
    DeviceSize                  compactedSize = {};
    AccelerationStructureInfoNV info          = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureCreateInfoNV>
  {
    using Type = AccelerationStructureCreateInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureCreateInfoNV>
  {
    using Type = AccelerationStructureCreateInfoNV;
  };

#if defined( VK_ENABLE_BETA_EXTENSIONS )
  // wrapper struct for struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX.html
  struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX
  {
    using NativeType = VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( DeviceOrHostAddressConstKHR  compressedData_    = {},
                                                                 DeviceSize                   dataSize_          = {},
                                                                 uint32_t                     numTriangles_      = {},
                                                                 uint32_t                     numVertices_       = {},
                                                                 uint32_t                     maxPrimitiveIndex_ = {},
                                                                 uint32_t                     maxGeometryIndex_  = {},
                                                                 CompressedTriangleFormatAMDX format_            = CompressedTriangleFormatAMDX::eDgf1,
                                                                 void const *                 pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , compressedData{ compressedData_ }
      , dataSize{ dataSize_ }
      , numTriangles{ numTriangles_ }
      , numVertices{ numVertices_ }
      , maxPrimitiveIndex{ maxPrimitiveIndex_ }
      , maxGeometryIndex{ maxGeometryIndex_ }
      , format{ format_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs )
      VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureDenseGeometryFormatTrianglesDataAMDX(
          *reinterpret_cast<AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *>( &rhs ) )
    {
    }

    AccelerationStructureDenseGeometryFormatTrianglesDataAMDX &
      operator=( AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureDenseGeometryFormatTrianglesDataAMDX &
      operator=( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX &
      setCompressedData( DeviceOrHostAddressConstKHR const & compressedData_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      compressedData = compressedData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX &&
      setCompressedData( DeviceOrHostAddressConstKHR const & compressedData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      compressedData = compressedData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setDataSize( DeviceSize dataSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setDataSize( DeviceSize dataSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setNumTriangles( uint32_t numTriangles_ ) & VULKAN_HPP_NOEXCEPT
    {
      numTriangles = numTriangles_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setNumTriangles( uint32_t numTriangles_ ) && VULKAN_HPP_NOEXCEPT
    {
      numTriangles = numTriangles_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setNumVertices( uint32_t numVertices_ ) & VULKAN_HPP_NOEXCEPT
    {
      numVertices = numVertices_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setNumVertices( uint32_t numVertices_ ) && VULKAN_HPP_NOEXCEPT
    {
      numVertices = numVertices_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setMaxPrimitiveIndex( uint32_t maxPrimitiveIndex_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxPrimitiveIndex = maxPrimitiveIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setMaxPrimitiveIndex( uint32_t maxPrimitiveIndex_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxPrimitiveIndex = maxPrimitiveIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setMaxGeometryIndex( uint32_t maxGeometryIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxGeometryIndex = maxGeometryIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setMaxGeometryIndex( uint32_t maxGeometryIndex_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxGeometryIndex = maxGeometryIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setFormat( CompressedTriangleFormatAMDX format_ ) & VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setFormat( CompressedTriangleFormatAMDX format_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *>( this );
    }

    operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *>( this );
    }

    operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *>( this );
    }

    operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               CompressedTriangleFormatAMDX const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, compressedData, dataSize, numTriangles, numVertices, maxPrimitiveIndex, maxGeometryIndex, format );
    }
#  endif

  public:
    StructureType                sType             = StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
    void const *                 pNext             = {};
    DeviceOrHostAddressConstKHR  compressedData    = {};
    DeviceSize                   dataSize          = {};
    uint32_t                     numTriangles      = {};
    uint32_t                     numVertices       = {};
    uint32_t                     maxPrimitiveIndex = {};
    uint32_t                     maxGeometryIndex  = {};
    CompressedTriangleFormatAMDX format            = CompressedTriangleFormatAMDX::eDgf1;
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX>
  {
    using Type = AccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX>
  {
    using Type = AccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
  };
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

  // wrapper struct for struct VkAccelerationStructureDeviceAddressInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html
  struct AccelerationStructureDeviceAddressInfoKHR
  {
    using NativeType = VkAccelerationStructureDeviceAddressInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureDeviceAddressInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( AccelerationStructureKHR accelerationStructure_ = {},
                                                                    void const *             pNext_                 = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , accelerationStructure{ accelerationStructure_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureDeviceAddressInfoKHR( VkAccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureDeviceAddressInfoKHR( *reinterpret_cast<AccelerationStructureDeviceAddressInfoKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureDeviceAddressInfoKHR & operator=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureDeviceAddressInfoKHR & operator=( VkAccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureDeviceAddressInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR & setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR && setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR const *>( this );
    }

    operator VkAccelerationStructureDeviceAddressInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR *>( this );
    }

    operator VkAccelerationStructureDeviceAddressInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR const *>( this );
    }

    operator VkAccelerationStructureDeviceAddressInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, AccelerationStructureKHR const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, accelerationStructure );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const & ) const = default;
#else
    bool operator==( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure );
#  endif
    }

    bool operator!=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType            sType                 = StructureType::eAccelerationStructureDeviceAddressInfoKHR;
    void const *             pNext                 = {};
    AccelerationStructureKHR accelerationStructure = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureDeviceAddressInfoKHR>
  {
    using Type = AccelerationStructureDeviceAddressInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureDeviceAddressInfoKHR>
  {
    using Type = AccelerationStructureDeviceAddressInfoKHR;
  };

  // wrapper struct for struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryLinearSweptSpheresDataNV.html
  struct AccelerationStructureGeometryLinearSweptSpheresDataNV
  {
    using NativeType = VkAccelerationStructureGeometryLinearSweptSpheresDataNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureGeometryLinearSweptSpheresDataNV( Format                              vertexFormat_ = Format::eUndefined,
                                                             DeviceOrHostAddressConstKHR         vertexData_   = {},
                                                             DeviceSize                          vertexStride_ = {},
                                                             Format                              radiusFormat_ = Format::eUndefined,
                                                             DeviceOrHostAddressConstKHR         radiusData_   = {},
                                                             DeviceSize                          radiusStride_ = {},
                                                             IndexType                           indexType_    = IndexType::eUint16,
                                                             DeviceOrHostAddressConstKHR         indexData_    = {},
                                                             DeviceSize                          indexStride_  = {},
                                                             RayTracingLssIndexingModeNV         indexingMode_ = RayTracingLssIndexingModeNV::eList,
                                                             RayTracingLssPrimitiveEndCapsModeNV endCapsMode_  = RayTracingLssPrimitiveEndCapsModeNV::eNone,
                                                             void const *                        pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , vertexFormat{ vertexFormat_ }
      , vertexData{ vertexData_ }
      , vertexStride{ vertexStride_ }
      , radiusFormat{ radiusFormat_ }
      , radiusData{ radiusData_ }
      , radiusStride{ radiusStride_ }
      , indexType{ indexType_ }
      , indexData{ indexData_ }
      , indexStride{ indexStride_ }
      , indexingMode{ indexingMode_ }
      , endCapsMode{ endCapsMode_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureGeometryLinearSweptSpheresDataNV( AccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureGeometryLinearSweptSpheresDataNV( VkAccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureGeometryLinearSweptSpheresDataNV( *reinterpret_cast<AccelerationStructureGeometryLinearSweptSpheresDataNV const *>( &rhs ) )
    {
    }

    AccelerationStructureGeometryLinearSweptSpheresDataNV &
      operator=( AccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureGeometryLinearSweptSpheresDataNV & operator=( VkAccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureGeometryLinearSweptSpheresDataNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexStride = vertexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexStride = vertexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setRadiusFormat( Format radiusFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      radiusFormat = radiusFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setRadiusFormat( Format radiusFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      radiusFormat = radiusFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      radiusData = radiusData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      radiusData = radiusData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setRadiusStride( DeviceSize radiusStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      radiusStride = radiusStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setRadiusStride( DeviceSize radiusStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      radiusStride = radiusStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      indexData = indexData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indexData = indexData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexingMode( RayTracingLssIndexingModeNV indexingMode_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      indexingMode = indexingMode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexingMode( RayTracingLssIndexingModeNV indexingMode_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indexingMode = indexingMode_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setEndCapsMode( RayTracingLssPrimitiveEndCapsModeNV endCapsMode_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      endCapsMode = endCapsMode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setEndCapsMode( RayTracingLssPrimitiveEndCapsModeNV endCapsMode_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      endCapsMode = endCapsMode_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryLinearSweptSpheresDataNV const *>( this );
    }

    operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryLinearSweptSpheresDataNV *>( this );
    }

    operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryLinearSweptSpheresDataNV const *>( this );
    }

    operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryLinearSweptSpheresDataNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               Format const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               Format const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               IndexType const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               RayTracingLssIndexingModeNV const &,
               RayTracingLssPrimitiveEndCapsModeNV const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       vertexFormat,
                       vertexData,
                       vertexStride,
                       radiusFormat,
                       radiusData,
                       radiusStride,
                       indexType,
                       indexData,
                       indexStride,
                       indexingMode,
                       endCapsMode );
    }
#endif

  public:
    StructureType                       sType        = StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV;
    void const *                        pNext        = {};
    Format                              vertexFormat = Format::eUndefined;
    DeviceOrHostAddressConstKHR         vertexData   = {};
    DeviceSize                          vertexStride = {};
    Format                              radiusFormat = Format::eUndefined;
    DeviceOrHostAddressConstKHR         radiusData   = {};
    DeviceSize                          radiusStride = {};
    IndexType                           indexType    = IndexType::eUint16;
    DeviceOrHostAddressConstKHR         indexData    = {};
    DeviceSize                          indexStride  = {};
    RayTracingLssIndexingModeNV         indexingMode = RayTracingLssIndexingModeNV::eList;
    RayTracingLssPrimitiveEndCapsModeNV endCapsMode  = RayTracingLssPrimitiveEndCapsModeNV::eNone;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureGeometryLinearSweptSpheresDataNV>
  {
    using Type = AccelerationStructureGeometryLinearSweptSpheresDataNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV>
  {
    using Type = AccelerationStructureGeometryLinearSweptSpheresDataNV;
  };

  // wrapper struct for struct VkMicromapUsageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapUsageKHR.html
  struct MicromapUsageKHR
  {
    using NativeType = VkMicromapUsageKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR MicromapUsageKHR( uint32_t                 count_            = {},
                                           uint32_t                 subdivisionLevel_ = {},
                                           OpacityMicromapFormatKHR format_           = OpacityMicromapFormatKHR::e2State ) VULKAN_HPP_NOEXCEPT
      : count{ count_ }
      , subdivisionLevel{ subdivisionLevel_ }
      , format{ format_ }
    {
    }

    VULKAN_HPP_CONSTEXPR MicromapUsageKHR( MicromapUsageKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    MicromapUsageKHR( VkMicromapUsageKHR const & rhs ) VULKAN_HPP_NOEXCEPT : MicromapUsageKHR( *reinterpret_cast<MicromapUsageKHR const *>( &rhs ) ) {}

    MicromapUsageKHR & operator=( MicromapUsageKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    MicromapUsageKHR & operator=( VkMicromapUsageKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<MicromapUsageKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR & setCount( uint32_t count_ ) & VULKAN_HPP_NOEXCEPT
    {
      count = count_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR && setCount( uint32_t count_ ) && VULKAN_HPP_NOEXCEPT
    {
      count = count_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR & setSubdivisionLevel( uint32_t subdivisionLevel_ ) & VULKAN_HPP_NOEXCEPT
    {
      subdivisionLevel = subdivisionLevel_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR && setSubdivisionLevel( uint32_t subdivisionLevel_ ) && VULKAN_HPP_NOEXCEPT
    {
      subdivisionLevel = subdivisionLevel_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR & setFormat( OpacityMicromapFormatKHR format_ ) & VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR && setFormat( OpacityMicromapFormatKHR format_ ) && VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkMicromapUsageKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkMicromapUsageKHR const *>( this );
    }

    operator VkMicromapUsageKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkMicromapUsageKHR *>( this );
    }

    operator VkMicromapUsageKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkMicromapUsageKHR const *>( this );
    }

    operator VkMicromapUsageKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkMicromapUsageKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, OpacityMicromapFormatKHR const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( count, subdivisionLevel, format );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( MicromapUsageKHR const & ) const = default;
#else
    bool operator==( MicromapUsageKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( count == rhs.count ) && ( subdivisionLevel == rhs.subdivisionLevel ) && ( format == rhs.format );
#  endif
    }

    bool operator!=( MicromapUsageKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t                 count            = {};
    uint32_t                 subdivisionLevel = {};
    OpacityMicromapFormatKHR format           = OpacityMicromapFormatKHR::e2State;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkMicromapUsageKHR>
  {
    using Type = MicromapUsageKHR;
  };
#endif

  // wrapper struct for struct VkAccelerationStructureGeometryMicromapDataKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryMicromapDataKHR.html
  struct AccelerationStructureGeometryMicromapDataKHR
  {
    using NativeType = VkAccelerationStructureGeometryMicromapDataKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureGeometryMicromapDataKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureGeometryMicromapDataKHR( uint32_t                         usageCountsCount_    = {},
                                                                       MicromapUsageKHR const *         pUsageCounts_        = {},
                                                                       MicromapUsageKHR const * const * ppUsageCounts_       = {},
                                                                       DeviceAddress                    data_                = {},
                                                                       DeviceAddress                    triangleArray_       = {},
                                                                       DeviceSize                       triangleArrayStride_ = {},
                                                                       void const *                     pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , usageCountsCount{ usageCountsCount_ }
      , pUsageCounts{ pUsageCounts_ }
      , ppUsageCounts{ ppUsageCounts_ }
      , data{ data_ }
      , triangleArray{ triangleArray_ }
      , triangleArrayStride{ triangleArrayStride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureGeometryMicromapDataKHR( AccelerationStructureGeometryMicromapDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureGeometryMicromapDataKHR( VkAccelerationStructureGeometryMicromapDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureGeometryMicromapDataKHR( *reinterpret_cast<AccelerationStructureGeometryMicromapDataKHR const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureGeometryMicromapDataKHR( ArrayProxyNoTemporaries<MicromapUsageKHR const> const &         usageCounts_,
                                                  ArrayProxyNoTemporaries<MicromapUsageKHR const * const> const & pUsageCounts_        = {},
                                                  DeviceAddress                                                   data_                = {},
                                                  DeviceAddress                                                   triangleArray_       = {},
                                                  DeviceSize                                                      triangleArrayStride_ = {},
                                                  void const *                                                    pNext_               = nullptr )
      : pNext( pNext_ )
      , usageCountsCount( static_cast<uint32_t>( !usageCounts_.empty() ? usageCounts_.size() : pUsageCounts_.size() ) )
      , pUsageCounts( usageCounts_.data() )
      , ppUsageCounts( pUsageCounts_.data() )
      , data( data_ )
      , triangleArray( triangleArray_ )
      , triangleArrayStride( triangleArrayStride_ )
    {
#    ifdef VULKAN_HPP_NO_EXCEPTIONS
      VULKAN_HPP_ASSERT( ( !usageCounts_.empty() + !pUsageCounts_.empty() ) <= 1 );
#    else
      if ( 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() ) )
      {
        throw LogicError(
          VULKAN_HPP_NAMESPACE_STRING
          "::AccelerationStructureGeometryMicromapDataKHR::AccelerationStructureGeometryMicromapDataKHR: 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() )" );
      }
#    endif /*VULKAN_HPP_NO_EXCEPTIONS*/
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    AccelerationStructureGeometryMicromapDataKHR & operator=( AccelerationStructureGeometryMicromapDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureGeometryMicromapDataKHR & operator=( VkAccelerationStructureGeometryMicromapDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureGeometryMicromapDataKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = usageCountsCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = usageCountsCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setPUsageCounts( MicromapUsageKHR const * pUsageCounts_ ) & VULKAN_HPP_NOEXCEPT
    {
      pUsageCounts = pUsageCounts_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setPUsageCounts( MicromapUsageKHR const * pUsageCounts_ ) && VULKAN_HPP_NOEXCEPT
    {
      pUsageCounts = pUsageCounts_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureGeometryMicromapDataKHR & setUsageCounts( ArrayProxyNoTemporaries<MicromapUsageKHR const> const & usageCounts_ ) VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = static_cast<uint32_t>( usageCounts_.size() );
      pUsageCounts     = usageCounts_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setPpUsageCounts( MicromapUsageKHR const * const * ppUsageCounts_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      ppUsageCounts = ppUsageCounts_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setPpUsageCounts( MicromapUsageKHR const * const * ppUsageCounts_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      ppUsageCounts = ppUsageCounts_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureGeometryMicromapDataKHR &
      setPUsageCounts( ArrayProxyNoTemporaries<MicromapUsageKHR const * const> const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = static_cast<uint32_t>( pUsageCounts_.size() );
      ppUsageCounts    = pUsageCounts_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setData( DeviceAddress data_ ) & VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setData( DeviceAddress data_ ) && VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setTriangleArray( DeviceAddress triangleArray_ ) & VULKAN_HPP_NOEXCEPT
    {
      triangleArray = triangleArray_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setTriangleArray( DeviceAddress triangleArray_ ) && VULKAN_HPP_NOEXCEPT
    {
      triangleArray = triangleArray_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setTriangleArrayStride( DeviceSize triangleArrayStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      triangleArrayStride = triangleArrayStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setTriangleArrayStride( DeviceSize triangleArrayStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      triangleArrayStride = triangleArrayStride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureGeometryMicromapDataKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryMicromapDataKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryMicromapDataKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryMicromapDataKHR *>( this );
    }

    operator VkAccelerationStructureGeometryMicromapDataKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryMicromapDataKHR const *>( this );
    }

    operator VkAccelerationStructureGeometryMicromapDataKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryMicromapDataKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               uint32_t const &,
               MicromapUsageKHR const * const &,
               MicromapUsageKHR const * const * const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, usageCountsCount, pUsageCounts, ppUsageCounts, data, triangleArray, triangleArrayStride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureGeometryMicromapDataKHR const & ) const = default;
#else
    bool operator==( AccelerationStructureGeometryMicromapDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usageCountsCount == rhs.usageCountsCount ) && ( pUsageCounts == rhs.pUsageCounts ) &&
             ( ppUsageCounts == rhs.ppUsageCounts ) && ( data == rhs.data ) && ( triangleArray == rhs.triangleArray ) &&
             ( triangleArrayStride == rhs.triangleArrayStride );
#  endif
    }

    bool operator!=( AccelerationStructureGeometryMicromapDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                    sType               = StructureType::eAccelerationStructureGeometryMicromapDataKHR;
    void const *                     pNext               = {};
    uint32_t                         usageCountsCount    = {};
    MicromapUsageKHR const *         pUsageCounts        = {};
    MicromapUsageKHR const * const * ppUsageCounts       = {};
    DeviceAddress                    data                = {};
    DeviceAddress                    triangleArray       = {};
    DeviceSize                       triangleArrayStride = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureGeometryMicromapDataKHR>
  {
    using Type = AccelerationStructureGeometryMicromapDataKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryMicromapDataKHR>
  {
    using Type = AccelerationStructureGeometryMicromapDataKHR;
  };

  // wrapper struct for struct VkAccelerationStructureGeometryMotionTrianglesDataNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html
  struct AccelerationStructureGeometryMotionTrianglesDataNV
  {
    using NativeType = VkAccelerationStructureGeometryMotionTrianglesDataNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV( DeviceOrHostAddressConstKHR vertexData_ = {},
                                                                                void const *                pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , vertexData{ vertexData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureGeometryMotionTrianglesDataNV( AccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureGeometryMotionTrianglesDataNV( VkAccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureGeometryMotionTrianglesDataNV( *reinterpret_cast<AccelerationStructureGeometryMotionTrianglesDataNV const *>( &rhs ) )
    {
    }

    AccelerationStructureGeometryMotionTrianglesDataNV &
      operator=( AccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureGeometryMotionTrianglesDataNV & operator=( VkAccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureGeometryMotionTrianglesDataNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV const *>( this );
    }

    operator VkAccelerationStructureGeometryMotionTrianglesDataNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV *>( this );
    }

    operator VkAccelerationStructureGeometryMotionTrianglesDataNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV const *>( this );
    }

    operator VkAccelerationStructureGeometryMotionTrianglesDataNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceOrHostAddressConstKHR const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, vertexData );
    }
#endif

  public:
    StructureType               sType      = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV;
    void const *                pNext      = {};
    DeviceOrHostAddressConstKHR vertexData = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureGeometryMotionTrianglesDataNV>
  {
    using Type = AccelerationStructureGeometryMotionTrianglesDataNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV>
  {
    using Type = AccelerationStructureGeometryMotionTrianglesDataNV;
  };

  // wrapper struct for struct VkAccelerationStructureGeometrySpheresDataNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometrySpheresDataNV.html
  struct AccelerationStructureGeometrySpheresDataNV
  {
    using NativeType = VkAccelerationStructureGeometrySpheresDataNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureGeometrySpheresDataNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV( Format                      vertexFormat_ = Format::eUndefined,
                                                                        DeviceOrHostAddressConstKHR vertexData_   = {},
                                                                        DeviceSize                  vertexStride_ = {},
                                                                        Format                      radiusFormat_ = Format::eUndefined,
                                                                        DeviceOrHostAddressConstKHR radiusData_   = {},
                                                                        DeviceSize                  radiusStride_ = {},
                                                                        IndexType                   indexType_    = IndexType::eUint16,
                                                                        DeviceOrHostAddressConstKHR indexData_    = {},
                                                                        DeviceSize                  indexStride_  = {},
                                                                        void const *                pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , vertexFormat{ vertexFormat_ }
      , vertexData{ vertexData_ }
      , vertexStride{ vertexStride_ }
      , radiusFormat{ radiusFormat_ }
      , radiusData{ radiusData_ }
      , radiusStride{ radiusStride_ }
      , indexType{ indexType_ }
      , indexData{ indexData_ }
      , indexStride{ indexStride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV( AccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureGeometrySpheresDataNV( VkAccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureGeometrySpheresDataNV( *reinterpret_cast<AccelerationStructureGeometrySpheresDataNV const *>( &rhs ) )
    {
    }

    AccelerationStructureGeometrySpheresDataNV & operator=( AccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureGeometrySpheresDataNV & operator=( VkAccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureGeometrySpheresDataNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      vertexData = vertexData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexStride = vertexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexStride = vertexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setRadiusFormat( Format radiusFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      radiusFormat = radiusFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setRadiusFormat( Format radiusFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      radiusFormat = radiusFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) & VULKAN_HPP_NOEXCEPT
    {
      radiusData = radiusData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      radiusData = radiusData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setRadiusStride( DeviceSize radiusStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      radiusStride = radiusStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setRadiusStride( DeviceSize radiusStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      radiusStride = radiusStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexData = indexData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexData = indexData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureGeometrySpheresDataNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometrySpheresDataNV const *>( this );
    }

    operator VkAccelerationStructureGeometrySpheresDataNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureGeometrySpheresDataNV *>( this );
    }

    operator VkAccelerationStructureGeometrySpheresDataNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometrySpheresDataNV const *>( this );
    }

    operator VkAccelerationStructureGeometrySpheresDataNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureGeometrySpheresDataNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               Format const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               Format const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               IndexType const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, vertexFormat, vertexData, vertexStride, radiusFormat, radiusData, radiusStride, indexType, indexData, indexStride );
    }
#endif

  public:
    StructureType               sType        = StructureType::eAccelerationStructureGeometrySpheresDataNV;
    void const *                pNext        = {};
    Format                      vertexFormat = Format::eUndefined;
    DeviceOrHostAddressConstKHR vertexData   = {};
    DeviceSize                  vertexStride = {};
    Format                      radiusFormat = Format::eUndefined;
    DeviceOrHostAddressConstKHR radiusData   = {};
    DeviceSize                  radiusStride = {};
    IndexType                   indexType    = IndexType::eUint16;
    DeviceOrHostAddressConstKHR indexData    = {};
    DeviceSize                  indexStride  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureGeometrySpheresDataNV>
  {
    using Type = AccelerationStructureGeometrySpheresDataNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureGeometrySpheresDataNV>
  {
    using Type = AccelerationStructureGeometrySpheresDataNV;
  };

  // wrapper struct for struct VkTransformMatrixKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTransformMatrixKHR.html
  struct TransformMatrixKHR
  {
    using NativeType = VkTransformMatrixKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( std::array<std::array<float, 4>, 3> const & matrix_ = {} ) VULKAN_HPP_NOEXCEPT : matrix{ matrix_ } {}

    VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( TransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    TransformMatrixKHR( VkTransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT : TransformMatrixKHR( *reinterpret_cast<TransformMatrixKHR const *>( &rhs ) ) {}

    TransformMatrixKHR & operator=( TransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    TransformMatrixKHR & operator=( VkTransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<TransformMatrixKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR & setMatrix( std::array<std::array<float, 4>, 3> matrix_ ) & VULKAN_HPP_NOEXCEPT
    {
      matrix = matrix_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR && setMatrix( std::array<std::array<float, 4>, 3> matrix_ ) && VULKAN_HPP_NOEXCEPT
    {
      matrix = matrix_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkTransformMatrixKHR const *>( this );
    }

    operator VkTransformMatrixKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkTransformMatrixKHR *>( this );
    }

    operator VkTransformMatrixKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkTransformMatrixKHR const *>( this );
    }

    operator VkTransformMatrixKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkTransformMatrixKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<ArrayWrapper2D<float, 3, 4> const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( matrix );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( TransformMatrixKHR const & ) const = default;
#else
    bool operator==( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( matrix == rhs.matrix );
#  endif
    }

    bool operator!=( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    ArrayWrapper2D<float, 3, 4> matrix = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkTransformMatrixKHR>
  {
    using Type = TransformMatrixKHR;
  };
#endif
  using TransformMatrixNV = TransformMatrixKHR;

  // wrapper struct for struct VkAccelerationStructureInstanceKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureInstanceKHR.html
  struct AccelerationStructureInstanceKHR
  {
    using NativeType = VkAccelerationStructureInstanceKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( TransformMatrixKHR       transform_                              = {},
                                                              uint32_t                 instanceCustomIndex_                    = {},
                                                              uint32_t                 mask_                                   = {},
                                                              uint32_t                 instanceShaderBindingTableRecordOffset_ = {},
                                                              GeometryInstanceFlagsKHR flags_                                  = {},
                                                              uint64_t                 accelerationStructureReference_         = {} ) VULKAN_HPP_NOEXCEPT
      : transform{ transform_ }
      , instanceCustomIndex{ instanceCustomIndex_ }
      , mask{ mask_ }
      , instanceShaderBindingTableRecordOffset{ instanceShaderBindingTableRecordOffset_ }
      , flags{ flags_ }
      , accelerationStructureReference{ accelerationStructureReference_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( AccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureInstanceKHR( VkAccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureInstanceKHR( *reinterpret_cast<AccelerationStructureInstanceKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureInstanceKHR & operator=( AccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureInstanceKHR & operator=( VkAccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureInstanceKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setTransform( TransformMatrixKHR const & transform_ ) & VULKAN_HPP_NOEXCEPT
    {
      transform = transform_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setTransform( TransformMatrixKHR const & transform_ ) && VULKAN_HPP_NOEXCEPT
    {
      transform = transform_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      instanceCustomIndex = instanceCustomIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      instanceCustomIndex = instanceCustomIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setMask( uint32_t mask_ ) & VULKAN_HPP_NOEXCEPT
    {
      mask = mask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setMask( uint32_t mask_ ) && VULKAN_HPP_NOEXCEPT
    {
      mask = mask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_;
      return std::move( *this );
    }

    AccelerationStructureInstanceKHR & setFlags( GeometryInstanceFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = *reinterpret_cast<VkGeometryInstanceFlagsKHR *>( &flags_ );
      return *this;
    }

    AccelerationStructureInstanceKHR && setFlags( GeometryInstanceFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = *reinterpret_cast<VkGeometryInstanceFlagsKHR *>( &flags_ );
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructureReference = accelerationStructureReference_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructureReference = accelerationStructureReference_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureInstanceKHR const *>( this );
    }

    operator VkAccelerationStructureInstanceKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureInstanceKHR *>( this );
    }

    operator VkAccelerationStructureInstanceKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureInstanceKHR const *>( this );
    }

    operator VkAccelerationStructureInstanceKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureInstanceKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<TransformMatrixKHR const &, uint32_t const &, uint32_t const &, uint32_t const &, VkGeometryInstanceFlagsKHR const &, uint64_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( transform, instanceCustomIndex, mask, instanceShaderBindingTableRecordOffset, flags, accelerationStructureReference );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureInstanceKHR const & ) const = default;
#else
    bool operator==( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( transform == rhs.transform ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) &&
             ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && ( flags == rhs.flags ) &&
             ( accelerationStructureReference == rhs.accelerationStructureReference );
#  endif
    }

    bool operator!=( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    TransformMatrixKHR         transform = {};
    uint32_t                   instanceCustomIndex                    : 24;
    uint32_t                   mask                                   : 8;
    uint32_t                   instanceShaderBindingTableRecordOffset : 24;
    VkGeometryInstanceFlagsKHR flags                                  : 8;
    uint64_t                   accelerationStructureReference = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureInstanceKHR>
  {
    using Type = AccelerationStructureInstanceKHR;
  };
#endif
  using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;

  // wrapper struct for struct VkAccelerationStructureMatrixMotionInstanceNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMatrixMotionInstanceNV.html
  struct AccelerationStructureMatrixMotionInstanceNV
  {
    using NativeType = VkAccelerationStructureMatrixMotionInstanceNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV( TransformMatrixKHR       transformT0_                            = {},
                                                                         TransformMatrixKHR       transformT1_                            = {},
                                                                         uint32_t                 instanceCustomIndex_                    = {},
                                                                         uint32_t                 mask_                                   = {},
                                                                         uint32_t                 instanceShaderBindingTableRecordOffset_ = {},
                                                                         GeometryInstanceFlagsKHR flags_                                  = {},
                                                                         uint64_t                 accelerationStructureReference_ = {} ) VULKAN_HPP_NOEXCEPT
      : transformT0{ transformT0_ }
      , transformT1{ transformT1_ }
      , instanceCustomIndex{ instanceCustomIndex_ }
      , mask{ mask_ }
      , instanceShaderBindingTableRecordOffset{ instanceShaderBindingTableRecordOffset_ }
      , flags{ flags_ }
      , accelerationStructureReference{ accelerationStructureReference_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureMatrixMotionInstanceNV( AccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureMatrixMotionInstanceNV( VkAccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureMatrixMotionInstanceNV( *reinterpret_cast<AccelerationStructureMatrixMotionInstanceNV const *>( &rhs ) )
    {
    }

    AccelerationStructureMatrixMotionInstanceNV & operator=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureMatrixMotionInstanceNV & operator=( VkAccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureMatrixMotionInstanceNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setTransformT0( TransformMatrixKHR const & transformT0_ ) & VULKAN_HPP_NOEXCEPT
    {
      transformT0 = transformT0_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setTransformT0( TransformMatrixKHR const & transformT0_ ) && VULKAN_HPP_NOEXCEPT
    {
      transformT0 = transformT0_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setTransformT1( TransformMatrixKHR const & transformT1_ ) & VULKAN_HPP_NOEXCEPT
    {
      transformT1 = transformT1_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setTransformT1( TransformMatrixKHR const & transformT1_ ) && VULKAN_HPP_NOEXCEPT
    {
      transformT1 = transformT1_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      instanceCustomIndex = instanceCustomIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      instanceCustomIndex = instanceCustomIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setMask( uint32_t mask_ ) & VULKAN_HPP_NOEXCEPT
    {
      mask = mask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setMask( uint32_t mask_ ) && VULKAN_HPP_NOEXCEPT
    {
      mask = mask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV &
      setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV &&
      setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_;
      return std::move( *this );
    }

    AccelerationStructureMatrixMotionInstanceNV & setFlags( GeometryInstanceFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = *reinterpret_cast<VkGeometryInstanceFlagsKHR *>( &flags_ );
      return *this;
    }

    AccelerationStructureMatrixMotionInstanceNV && setFlags( GeometryInstanceFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = *reinterpret_cast<VkGeometryInstanceFlagsKHR *>( &flags_ );
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructureReference = accelerationStructureReference_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructureReference = accelerationStructureReference_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureMatrixMotionInstanceNV const *>( this );
    }

    operator VkAccelerationStructureMatrixMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureMatrixMotionInstanceNV *>( this );
    }

    operator VkAccelerationStructureMatrixMotionInstanceNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureMatrixMotionInstanceNV const *>( this );
    }

    operator VkAccelerationStructureMatrixMotionInstanceNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureMatrixMotionInstanceNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<TransformMatrixKHR const &,
               TransformMatrixKHR const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               VkGeometryInstanceFlagsKHR const &,
               uint64_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( transformT0, transformT1, instanceCustomIndex, mask, instanceShaderBindingTableRecordOffset, flags, accelerationStructureReference );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureMatrixMotionInstanceNV const & ) const = default;
#else
    bool operator==( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) &&
             ( mask == rhs.mask ) && ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && ( flags == rhs.flags ) &&
             ( accelerationStructureReference == rhs.accelerationStructureReference );
#  endif
    }

    bool operator!=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    TransformMatrixKHR         transformT0 = {};
    TransformMatrixKHR         transformT1 = {};
    uint32_t                   instanceCustomIndex                    : 24;
    uint32_t                   mask                                   : 8;
    uint32_t                   instanceShaderBindingTableRecordOffset : 24;
    VkGeometryInstanceFlagsKHR flags                                  : 8;
    uint64_t                   accelerationStructureReference = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureMatrixMotionInstanceNV>
  {
    using Type = AccelerationStructureMatrixMotionInstanceNV;
  };
#endif

  // wrapper struct for struct VkAccelerationStructureMemoryRequirementsInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html
  struct AccelerationStructureMemoryRequirementsInfoNV
  {
    using NativeType = VkAccelerationStructureMemoryRequirementsInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV(
      AccelerationStructureMemoryRequirementsTypeNV type_                  = AccelerationStructureMemoryRequirementsTypeNV::eObject,
      AccelerationStructureNV                       accelerationStructure_ = {},
      void const *                                  pNext_                 = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , type{ type_ }
      , accelerationStructure{ accelerationStructure_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureMemoryRequirementsInfoNV( *reinterpret_cast<AccelerationStructureMemoryRequirementsInfoNV const *>( &rhs ) )
    {
    }

    AccelerationStructureMemoryRequirementsInfoNV & operator=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureMemoryRequirementsInfoNV & operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureMemoryRequirementsInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV & setType( AccelerationStructureMemoryRequirementsTypeNV type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV && setType( AccelerationStructureMemoryRequirementsTypeNV type_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV && setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV const *>( this );
    }

    operator VkAccelerationStructureMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV *>( this );
    }

    operator VkAccelerationStructureMemoryRequirementsInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV const *>( this );
    }

    operator VkAccelerationStructureMemoryRequirementsInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, AccelerationStructureMemoryRequirementsTypeNV const &, AccelerationStructureNV const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, type, accelerationStructure );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const & ) const = default;
#else
    bool operator==( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( accelerationStructure == rhs.accelerationStructure );
#  endif
    }

    bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                                 sType                 = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
    void const *                                  pNext                 = {};
    AccelerationStructureMemoryRequirementsTypeNV type                  = AccelerationStructureMemoryRequirementsTypeNV::eObject;
    AccelerationStructureNV                       accelerationStructure = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureMemoryRequirementsInfoNV>
  {
    using Type = AccelerationStructureMemoryRequirementsInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureMemoryRequirementsInfoNV>
  {
    using Type = AccelerationStructureMemoryRequirementsInfoNV;
  };

  // wrapper struct for struct VkAccelerationStructureMotionInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInfoNV.html
  struct AccelerationStructureMotionInfoNV
  {
    using NativeType = VkAccelerationStructureMotionInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureMotionInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureMotionInfoNV( uint32_t                               maxInstances_ = {},
                                                            AccelerationStructureMotionInfoFlagsNV flags_        = {},
                                                            void const *                           pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , maxInstances{ maxInstances_ }
      , flags{ flags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureMotionInfoNV( AccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureMotionInfoNV( VkAccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureMotionInfoNV( *reinterpret_cast<AccelerationStructureMotionInfoNV const *>( &rhs ) )
    {
    }

    AccelerationStructureMotionInfoNV & operator=( AccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureMotionInfoNV & operator=( VkAccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureMotionInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV & setMaxInstances( uint32_t maxInstances_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxInstances = maxInstances_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV && setMaxInstances( uint32_t maxInstances_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxInstances = maxInstances_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV & setFlags( AccelerationStructureMotionInfoFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV && setFlags( AccelerationStructureMotionInfoFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureMotionInfoNV const *>( this );
    }

    operator VkAccelerationStructureMotionInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureMotionInfoNV *>( this );
    }

    operator VkAccelerationStructureMotionInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureMotionInfoNV const *>( this );
    }

    operator VkAccelerationStructureMotionInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureMotionInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, AccelerationStructureMotionInfoFlagsNV const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, maxInstances, flags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureMotionInfoNV const & ) const = default;
#else
    bool operator==( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) && ( flags == rhs.flags );
#  endif
    }

    bool operator!=( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                          sType        = StructureType::eAccelerationStructureMotionInfoNV;
    void const *                           pNext        = {};
    uint32_t                               maxInstances = {};
    AccelerationStructureMotionInfoFlagsNV flags        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureMotionInfoNV>
  {
    using Type = AccelerationStructureMotionInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureMotionInfoNV>
  {
    using Type = AccelerationStructureMotionInfoNV;
  };

  // wrapper struct for struct VkSRTDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSRTDataNV.html
  struct SRTDataNV
  {
    using NativeType = VkSRTDataNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SRTDataNV( float sx_  = {},
                                    float a_   = {},
                                    float b_   = {},
                                    float pvx_ = {},
                                    float sy_  = {},
                                    float c_   = {},
                                    float pvy_ = {},
                                    float sz_  = {},
                                    float pvz_ = {},
                                    float qx_  = {},
                                    float qy_  = {},
                                    float qz_  = {},
                                    float qw_  = {},
                                    float tx_  = {},
                                    float ty_  = {},
                                    float tz_  = {} ) VULKAN_HPP_NOEXCEPT
      : sx{ sx_ }
      , a{ a_ }
      , b{ b_ }
      , pvx{ pvx_ }
      , sy{ sy_ }
      , c{ c_ }
      , pvy{ pvy_ }
      , sz{ sz_ }
      , pvz{ pvz_ }
      , qx{ qx_ }
      , qy{ qy_ }
      , qz{ qz_ }
      , qw{ qw_ }
      , tx{ tx_ }
      , ty{ ty_ }
      , tz{ tz_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SRTDataNV( SRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SRTDataNV( VkSRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT : SRTDataNV( *reinterpret_cast<SRTDataNV const *>( &rhs ) ) {}

    SRTDataNV & operator=( SRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SRTDataNV & operator=( VkSRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SRTDataNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setSx( float sx_ ) & VULKAN_HPP_NOEXCEPT
    {
      sx = sx_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setSx( float sx_ ) && VULKAN_HPP_NOEXCEPT
    {
      sx = sx_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setA( float a_ ) & VULKAN_HPP_NOEXCEPT
    {
      a = a_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setA( float a_ ) && VULKAN_HPP_NOEXCEPT
    {
      a = a_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setB( float b_ ) & VULKAN_HPP_NOEXCEPT
    {
      b = b_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setB( float b_ ) && VULKAN_HPP_NOEXCEPT
    {
      b = b_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setPvx( float pvx_ ) & VULKAN_HPP_NOEXCEPT
    {
      pvx = pvx_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setPvx( float pvx_ ) && VULKAN_HPP_NOEXCEPT
    {
      pvx = pvx_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setSy( float sy_ ) & VULKAN_HPP_NOEXCEPT
    {
      sy = sy_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setSy( float sy_ ) && VULKAN_HPP_NOEXCEPT
    {
      sy = sy_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setC( float c_ ) & VULKAN_HPP_NOEXCEPT
    {
      c = c_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setC( float c_ ) && VULKAN_HPP_NOEXCEPT
    {
      c = c_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setPvy( float pvy_ ) & VULKAN_HPP_NOEXCEPT
    {
      pvy = pvy_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setPvy( float pvy_ ) && VULKAN_HPP_NOEXCEPT
    {
      pvy = pvy_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setSz( float sz_ ) & VULKAN_HPP_NOEXCEPT
    {
      sz = sz_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setSz( float sz_ ) && VULKAN_HPP_NOEXCEPT
    {
      sz = sz_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setPvz( float pvz_ ) & VULKAN_HPP_NOEXCEPT
    {
      pvz = pvz_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setPvz( float pvz_ ) && VULKAN_HPP_NOEXCEPT
    {
      pvz = pvz_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQx( float qx_ ) & VULKAN_HPP_NOEXCEPT
    {
      qx = qx_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQx( float qx_ ) && VULKAN_HPP_NOEXCEPT
    {
      qx = qx_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQy( float qy_ ) & VULKAN_HPP_NOEXCEPT
    {
      qy = qy_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQy( float qy_ ) && VULKAN_HPP_NOEXCEPT
    {
      qy = qy_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQz( float qz_ ) & VULKAN_HPP_NOEXCEPT
    {
      qz = qz_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQz( float qz_ ) && VULKAN_HPP_NOEXCEPT
    {
      qz = qz_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQw( float qw_ ) & VULKAN_HPP_NOEXCEPT
    {
      qw = qw_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQw( float qw_ ) && VULKAN_HPP_NOEXCEPT
    {
      qw = qw_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setTx( float tx_ ) & VULKAN_HPP_NOEXCEPT
    {
      tx = tx_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setTx( float tx_ ) && VULKAN_HPP_NOEXCEPT
    {
      tx = tx_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setTy( float ty_ ) & VULKAN_HPP_NOEXCEPT
    {
      ty = ty_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setTy( float ty_ ) && VULKAN_HPP_NOEXCEPT
    {
      ty = ty_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setTz( float tz_ ) & VULKAN_HPP_NOEXCEPT
    {
      tz = tz_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setTz( float tz_ ) && VULKAN_HPP_NOEXCEPT
    {
      tz = tz_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSRTDataNV const *>( this );
    }

    operator VkSRTDataNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSRTDataNV *>( this );
    }

    operator VkSRTDataNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSRTDataNV const *>( this );
    }

    operator VkSRTDataNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSRTDataNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &,
               float const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sx, a, b, pvx, sy, c, pvy, sz, pvz, qx, qy, qz, qw, tx, ty, tz );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SRTDataNV const & ) const = default;
#else
    bool operator==( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sx == rhs.sx ) && ( a == rhs.a ) && ( b == rhs.b ) && ( pvx == rhs.pvx ) && ( sy == rhs.sy ) && ( c == rhs.c ) && ( pvy == rhs.pvy ) &&
             ( sz == rhs.sz ) && ( pvz == rhs.pvz ) && ( qx == rhs.qx ) && ( qy == rhs.qy ) && ( qz == rhs.qz ) && ( qw == rhs.qw ) && ( tx == rhs.tx ) &&
             ( ty == rhs.ty ) && ( tz == rhs.tz );
#  endif
    }

    bool operator!=( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    float sx  = {};
    float a   = {};
    float b   = {};
    float pvx = {};
    float sy  = {};
    float c   = {};
    float pvy = {};
    float sz  = {};
    float pvz = {};
    float qx  = {};
    float qy  = {};
    float qz  = {};
    float qw  = {};
    float tx  = {};
    float ty  = {};
    float tz  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSRTDataNV>
  {
    using Type = SRTDataNV;
  };
#endif

  // wrapper struct for struct VkAccelerationStructureSRTMotionInstanceNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureSRTMotionInstanceNV.html
  struct AccelerationStructureSRTMotionInstanceNV
  {
    using NativeType = VkAccelerationStructureSRTMotionInstanceNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureSRTMotionInstanceNV( SRTDataNV                transformT0_                            = {},
                                                                   SRTDataNV                transformT1_                            = {},
                                                                   uint32_t                 instanceCustomIndex_                    = {},
                                                                   uint32_t                 mask_                                   = {},
                                                                   uint32_t                 instanceShaderBindingTableRecordOffset_ = {},
                                                                   GeometryInstanceFlagsKHR flags_                                  = {},
                                                                   uint64_t                 accelerationStructureReference_         = {} ) VULKAN_HPP_NOEXCEPT
      : transformT0{ transformT0_ }
      , transformT1{ transformT1_ }
      , instanceCustomIndex{ instanceCustomIndex_ }
      , mask{ mask_ }
      , instanceShaderBindingTableRecordOffset{ instanceShaderBindingTableRecordOffset_ }
      , flags{ flags_ }
      , accelerationStructureReference{ accelerationStructureReference_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureSRTMotionInstanceNV( AccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureSRTMotionInstanceNV( VkAccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureSRTMotionInstanceNV( *reinterpret_cast<AccelerationStructureSRTMotionInstanceNV const *>( &rhs ) )
    {
    }

    AccelerationStructureSRTMotionInstanceNV & operator=( AccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureSRTMotionInstanceNV & operator=( VkAccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureSRTMotionInstanceNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setTransformT0( SRTDataNV const & transformT0_ ) & VULKAN_HPP_NOEXCEPT
    {
      transformT0 = transformT0_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setTransformT0( SRTDataNV const & transformT0_ ) && VULKAN_HPP_NOEXCEPT
    {
      transformT0 = transformT0_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setTransformT1( SRTDataNV const & transformT1_ ) & VULKAN_HPP_NOEXCEPT
    {
      transformT1 = transformT1_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setTransformT1( SRTDataNV const & transformT1_ ) && VULKAN_HPP_NOEXCEPT
    {
      transformT1 = transformT1_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      instanceCustomIndex = instanceCustomIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      instanceCustomIndex = instanceCustomIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setMask( uint32_t mask_ ) & VULKAN_HPP_NOEXCEPT
    {
      mask = mask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setMask( uint32_t mask_ ) && VULKAN_HPP_NOEXCEPT
    {
      mask = mask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV &
      setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV &&
      setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_;
      return std::move( *this );
    }

    AccelerationStructureSRTMotionInstanceNV & setFlags( GeometryInstanceFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = *reinterpret_cast<VkGeometryInstanceFlagsKHR *>( &flags_ );
      return *this;
    }

    AccelerationStructureSRTMotionInstanceNV && setFlags( GeometryInstanceFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = *reinterpret_cast<VkGeometryInstanceFlagsKHR *>( &flags_ );
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructureReference = accelerationStructureReference_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructureReference = accelerationStructureReference_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureSRTMotionInstanceNV const *>( this );
    }

    operator VkAccelerationStructureSRTMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureSRTMotionInstanceNV *>( this );
    }

    operator VkAccelerationStructureSRTMotionInstanceNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureSRTMotionInstanceNV const *>( this );
    }

    operator VkAccelerationStructureSRTMotionInstanceNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureSRTMotionInstanceNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<SRTDataNV const &, SRTDataNV const &, uint32_t const &, uint32_t const &, uint32_t const &, VkGeometryInstanceFlagsKHR const &, uint64_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( transformT0, transformT1, instanceCustomIndex, mask, instanceShaderBindingTableRecordOffset, flags, accelerationStructureReference );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureSRTMotionInstanceNV const & ) const = default;
#else
    bool operator==( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) &&
             ( mask == rhs.mask ) && ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && ( flags == rhs.flags ) &&
             ( accelerationStructureReference == rhs.accelerationStructureReference );
#  endif
    }

    bool operator!=( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    SRTDataNV                  transformT0 = {};
    SRTDataNV                  transformT1 = {};
    uint32_t                   instanceCustomIndex                    : 24;
    uint32_t                   mask                                   : 8;
    uint32_t                   instanceShaderBindingTableRecordOffset : 24;
    VkGeometryInstanceFlagsKHR flags                                  : 8;
    uint64_t                   accelerationStructureReference = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureSRTMotionInstanceNV>
  {
    using Type = AccelerationStructureSRTMotionInstanceNV;
  };
#endif

  union AccelerationStructureMotionInstanceDataNV
  {
    using NativeType = VkAccelerationStructureMotionInstanceDataNV;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV( AccelerationStructureInstanceKHR staticInstance_ = {} )
      : staticInstance( staticInstance_ )
    {
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV( AccelerationStructureMatrixMotionInstanceNV matrixMotionInstance_ )
      : matrixMotionInstance( matrixMotionInstance_ )
    {
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV( AccelerationStructureSRTMotionInstanceNV srtMotionInstance_ )
      : srtMotionInstance( srtMotionInstance_ )
    {
    }
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV & setStaticInstance( AccelerationStructureInstanceKHR const & staticInstance_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      staticInstance = staticInstance_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV && setStaticInstance( AccelerationStructureInstanceKHR const & staticInstance_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      staticInstance = staticInstance_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV &
      setMatrixMotionInstance( AccelerationStructureMatrixMotionInstanceNV const & matrixMotionInstance_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      matrixMotionInstance = matrixMotionInstance_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV &&
      setMatrixMotionInstance( AccelerationStructureMatrixMotionInstanceNV const & matrixMotionInstance_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      matrixMotionInstance = matrixMotionInstance_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV &
      setSrtMotionInstance( AccelerationStructureSRTMotionInstanceNV const & srtMotionInstance_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      srtMotionInstance = srtMotionInstance_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV &&
      setSrtMotionInstance( AccelerationStructureSRTMotionInstanceNV const & srtMotionInstance_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      srtMotionInstance = srtMotionInstance_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureMotionInstanceDataNV const &() const
    {
      return *reinterpret_cast<VkAccelerationStructureMotionInstanceDataNV const *>( this );
    }

    operator VkAccelerationStructureMotionInstanceDataNV &()
    {
      return *reinterpret_cast<VkAccelerationStructureMotionInstanceDataNV *>( this );
    }

#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    AccelerationStructureInstanceKHR            staticInstance;
    AccelerationStructureMatrixMotionInstanceNV matrixMotionInstance;
    AccelerationStructureSRTMotionInstanceNV    srtMotionInstance;
#else
    VkAccelerationStructureInstanceKHR            staticInstance;
    VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance;
    VkAccelerationStructureSRTMotionInstanceNV    srtMotionInstance;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureMotionInstanceDataNV>
  {
    using Type = AccelerationStructureMotionInstanceDataNV;
  };
#endif

  // wrapper struct for struct VkAccelerationStructureMotionInstanceNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceNV.html
  struct AccelerationStructureMotionInstanceNV
  {
    using NativeType = VkAccelerationStructureMotionInstanceNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureMotionInstanceNV( AccelerationStructureMotionInstanceTypeNV  type_  = AccelerationStructureMotionInstanceTypeNV::eStatic,
                                             AccelerationStructureMotionInstanceFlagsNV flags_ = {},
                                             AccelerationStructureMotionInstanceDataNV  data_  = {} ) VULKAN_HPP_NOEXCEPT
      : type{ type_ }
      , flags{ flags_ }
      , data{ data_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV( AccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureMotionInstanceNV( VkAccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureMotionInstanceNV( *reinterpret_cast<AccelerationStructureMotionInstanceNV const *>( &rhs ) )
    {
    }

    AccelerationStructureMotionInstanceNV & operator=( AccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureMotionInstanceNV & operator=( VkAccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureMotionInstanceNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV & setType( AccelerationStructureMotionInstanceTypeNV type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV && setType( AccelerationStructureMotionInstanceTypeNV type_ ) && VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV & setFlags( AccelerationStructureMotionInstanceFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV && setFlags( AccelerationStructureMotionInstanceFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV & setData( AccelerationStructureMotionInstanceDataNV const & data_ ) & VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV && setData( AccelerationStructureMotionInstanceDataNV const & data_ ) && VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureMotionInstanceNV const *>( this );
    }

    operator VkAccelerationStructureMotionInstanceNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureMotionInstanceNV *>( this );
    }

    operator VkAccelerationStructureMotionInstanceNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureMotionInstanceNV const *>( this );
    }

    operator VkAccelerationStructureMotionInstanceNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureMotionInstanceNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<AccelerationStructureMotionInstanceTypeNV const &,
               AccelerationStructureMotionInstanceFlagsNV const &,
               AccelerationStructureMotionInstanceDataNV const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( type, flags, data );
    }
#endif

  public:
    AccelerationStructureMotionInstanceTypeNV  type  = AccelerationStructureMotionInstanceTypeNV::eStatic;
    AccelerationStructureMotionInstanceFlagsNV flags = {};
    AccelerationStructureMotionInstanceDataNV  data  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureMotionInstanceNV>
  {
    using Type = AccelerationStructureMotionInstanceNV;
  };
#endif

  // wrapper struct for struct VkMicromapUsageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapUsageEXT.html
  struct MicromapUsageEXT
  {
    using NativeType = VkMicromapUsageEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR MicromapUsageEXT( uint32_t count_ = {}, uint32_t subdivisionLevel_ = {}, uint32_t format_ = {} ) VULKAN_HPP_NOEXCEPT
      : count{ count_ }
      , subdivisionLevel{ subdivisionLevel_ }
      , format{ format_ }
    {
    }

    VULKAN_HPP_CONSTEXPR MicromapUsageEXT( MicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    MicromapUsageEXT( VkMicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT : MicromapUsageEXT( *reinterpret_cast<MicromapUsageEXT const *>( &rhs ) ) {}

    MicromapUsageEXT & operator=( MicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    MicromapUsageEXT & operator=( VkMicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<MicromapUsageEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT & setCount( uint32_t count_ ) & VULKAN_HPP_NOEXCEPT
    {
      count = count_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT && setCount( uint32_t count_ ) && VULKAN_HPP_NOEXCEPT
    {
      count = count_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT & setSubdivisionLevel( uint32_t subdivisionLevel_ ) & VULKAN_HPP_NOEXCEPT
    {
      subdivisionLevel = subdivisionLevel_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT && setSubdivisionLevel( uint32_t subdivisionLevel_ ) && VULKAN_HPP_NOEXCEPT
    {
      subdivisionLevel = subdivisionLevel_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT & setFormat( uint32_t format_ ) & VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT && setFormat( uint32_t format_ ) && VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkMicromapUsageEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkMicromapUsageEXT const *>( this );
    }

    operator VkMicromapUsageEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkMicromapUsageEXT *>( this );
    }

    operator VkMicromapUsageEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkMicromapUsageEXT const *>( this );
    }

    operator VkMicromapUsageEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkMicromapUsageEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( count, subdivisionLevel, format );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( MicromapUsageEXT const & ) const = default;
#else
    bool operator==( MicromapUsageEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( count == rhs.count ) && ( subdivisionLevel == rhs.subdivisionLevel ) && ( format == rhs.format );
#  endif
    }

    bool operator!=( MicromapUsageEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t count            = {};
    uint32_t subdivisionLevel = {};
    uint32_t format           = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkMicromapUsageEXT>
  {
    using Type = MicromapUsageEXT;
  };
#endif

#if defined( VK_ENABLE_BETA_EXTENSIONS )
  // wrapper struct for struct VkAccelerationStructureTrianglesDisplacementMicromapNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesDisplacementMicromapNV.html
  struct AccelerationStructureTrianglesDisplacementMicromapNV
  {
    using NativeType = VkAccelerationStructureTrianglesDisplacementMicromapNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV( Format displacementBiasAndScaleFormat_ = Format::eUndefined,
                                                                                  Format displacementVectorFormat_       = Format::eUndefined,
                                                                                  DeviceOrHostAddressConstKHR      displacementBiasAndScaleBuffer_        = {},
                                                                                  DeviceSize                       displacementBiasAndScaleStride_        = {},
                                                                                  DeviceOrHostAddressConstKHR      displacementVectorBuffer_              = {},
                                                                                  DeviceSize                       displacementVectorStride_              = {},
                                                                                  DeviceOrHostAddressConstKHR      displacedMicromapPrimitiveFlags_       = {},
                                                                                  DeviceSize                       displacedMicromapPrimitiveFlagsStride_ = {},
                                                                                  IndexType                        indexType_        = IndexType::eUint16,
                                                                                  DeviceOrHostAddressConstKHR      indexBuffer_      = {},
                                                                                  DeviceSize                       indexStride_      = {},
                                                                                  uint32_t                         baseTriangle_     = {},
                                                                                  uint32_t                         usageCountsCount_ = {},
                                                                                  MicromapUsageEXT const *         pUsageCounts_     = {},
                                                                                  MicromapUsageEXT const * const * ppUsageCounts_    = {},
                                                                                  MicromapEXT                      micromap_         = {},
                                                                                  void *                           pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , displacementBiasAndScaleFormat{ displacementBiasAndScaleFormat_ }
      , displacementVectorFormat{ displacementVectorFormat_ }
      , displacementBiasAndScaleBuffer{ displacementBiasAndScaleBuffer_ }
      , displacementBiasAndScaleStride{ displacementBiasAndScaleStride_ }
      , displacementVectorBuffer{ displacementVectorBuffer_ }
      , displacementVectorStride{ displacementVectorStride_ }
      , displacedMicromapPrimitiveFlags{ displacedMicromapPrimitiveFlags_ }
      , displacedMicromapPrimitiveFlagsStride{ displacedMicromapPrimitiveFlagsStride_ }
      , indexType{ indexType_ }
      , indexBuffer{ indexBuffer_ }
      , indexStride{ indexStride_ }
      , baseTriangle{ baseTriangle_ }
      , usageCountsCount{ usageCountsCount_ }
      , pUsageCounts{ pUsageCounts_ }
      , ppUsageCounts{ ppUsageCounts_ }
      , micromap{ micromap_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureTrianglesDisplacementMicromapNV( AccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureTrianglesDisplacementMicromapNV( VkAccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureTrianglesDisplacementMicromapNV( *reinterpret_cast<AccelerationStructureTrianglesDisplacementMicromapNV const *>( &rhs ) )
    {
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureTrianglesDisplacementMicromapNV( Format                                                  displacementBiasAndScaleFormat_,
                                                          Format                                                  displacementVectorFormat_,
                                                          DeviceOrHostAddressConstKHR                             displacementBiasAndScaleBuffer_,
                                                          DeviceSize                                              displacementBiasAndScaleStride_,
                                                          DeviceOrHostAddressConstKHR                             displacementVectorBuffer_,
                                                          DeviceSize                                              displacementVectorStride_,
                                                          DeviceOrHostAddressConstKHR                             displacedMicromapPrimitiveFlags_,
                                                          DeviceSize                                              displacedMicromapPrimitiveFlagsStride_,
                                                          IndexType                                               indexType_,
                                                          DeviceOrHostAddressConstKHR                             indexBuffer_,
                                                          DeviceSize                                              indexStride_,
                                                          uint32_t                                                baseTriangle_,
                                                          ArrayProxyNoTemporaries<MicromapUsageEXT const> const & usageCounts_,
                                                          ArrayProxyNoTemporaries<MicromapUsageEXT const * const> const & pUsageCounts_ = {},
                                                          MicromapEXT                                                     micromap_     = {},
                                                          void *                                                          pNext_        = nullptr )
      : pNext( pNext_ )
      , displacementBiasAndScaleFormat( displacementBiasAndScaleFormat_ )
      , displacementVectorFormat( displacementVectorFormat_ )
      , displacementBiasAndScaleBuffer( displacementBiasAndScaleBuffer_ )
      , displacementBiasAndScaleStride( displacementBiasAndScaleStride_ )
      , displacementVectorBuffer( displacementVectorBuffer_ )
      , displacementVectorStride( displacementVectorStride_ )
      , displacedMicromapPrimitiveFlags( displacedMicromapPrimitiveFlags_ )
      , displacedMicromapPrimitiveFlagsStride( displacedMicromapPrimitiveFlagsStride_ )
      , indexType( indexType_ )
      , indexBuffer( indexBuffer_ )
      , indexStride( indexStride_ )
      , baseTriangle( baseTriangle_ )
      , usageCountsCount( static_cast<uint32_t>( usageCounts_.size() ) )
      , pUsageCounts( usageCounts_.data() )
      , ppUsageCounts( pUsageCounts_.data() )
      , micromap( micromap_ )
    {
#      ifdef VULKAN_HPP_NO_EXCEPTIONS
      VULKAN_HPP_ASSERT( usageCounts_.empty() || pUsageCounts_.empty() || ( usageCounts_.size() == pUsageCounts_.size() ) );
#      else
      if ( !usageCounts_.empty() && !pUsageCounts_.empty() && ( usageCounts_.size() != pUsageCounts_.size() ) )
      {
        throw LogicError(
          VULKAN_HPP_NAMESPACE_STRING
          "::AccelerationStructureTrianglesDisplacementMicromapNV::AccelerationStructureTrianglesDisplacementMicromapNV: !usageCounts_.empty() && !pUsageCounts_.empty() && ( usageCounts_.size() != pUsageCounts_.size() )" );
      }
#      endif /*VULKAN_HPP_NO_EXCEPTIONS*/
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    AccelerationStructureTrianglesDisplacementMicromapNV &
      operator=( AccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureTrianglesDisplacementMicromapNV & operator=( VkAccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureTrianglesDisplacementMicromapNV const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setDisplacementBiasAndScaleFormat( Format displacementBiasAndScaleFormat_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      displacementBiasAndScaleFormat = displacementBiasAndScaleFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &&
      setDisplacementBiasAndScaleFormat( Format displacementBiasAndScaleFormat_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      displacementBiasAndScaleFormat = displacementBiasAndScaleFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setDisplacementVectorFormat( Format displacementVectorFormat_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      displacementVectorFormat = displacementVectorFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setDisplacementVectorFormat( Format displacementVectorFormat_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      displacementVectorFormat = displacementVectorFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &
      setDisplacementBiasAndScaleBuffer( DeviceOrHostAddressConstKHR const & displacementBiasAndScaleBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      displacementBiasAndScaleBuffer = displacementBiasAndScaleBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &&
      setDisplacementBiasAndScaleBuffer( DeviceOrHostAddressConstKHR const & displacementBiasAndScaleBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      displacementBiasAndScaleBuffer = displacementBiasAndScaleBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &
      setDisplacementBiasAndScaleStride( DeviceSize displacementBiasAndScaleStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      displacementBiasAndScaleStride = displacementBiasAndScaleStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &&
      setDisplacementBiasAndScaleStride( DeviceSize displacementBiasAndScaleStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      displacementBiasAndScaleStride = displacementBiasAndScaleStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &
      setDisplacementVectorBuffer( DeviceOrHostAddressConstKHR const & displacementVectorBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      displacementVectorBuffer = displacementVectorBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &&
      setDisplacementVectorBuffer( DeviceOrHostAddressConstKHR const & displacementVectorBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      displacementVectorBuffer = displacementVectorBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setDisplacementVectorStride( DeviceSize displacementVectorStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      displacementVectorStride = displacementVectorStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setDisplacementVectorStride( DeviceSize displacementVectorStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      displacementVectorStride = displacementVectorStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &
      setDisplacedMicromapPrimitiveFlags( DeviceOrHostAddressConstKHR const & displacedMicromapPrimitiveFlags_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      displacedMicromapPrimitiveFlags = displacedMicromapPrimitiveFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &&
      setDisplacedMicromapPrimitiveFlags( DeviceOrHostAddressConstKHR const & displacedMicromapPrimitiveFlags_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      displacedMicromapPrimitiveFlags = displacedMicromapPrimitiveFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &
      setDisplacedMicromapPrimitiveFlagsStride( DeviceSize displacedMicromapPrimitiveFlagsStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      displacedMicromapPrimitiveFlagsStride = displacedMicromapPrimitiveFlagsStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV &&
      setDisplacedMicromapPrimitiveFlagsStride( DeviceSize displacedMicromapPrimitiveFlagsStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      displacedMicromapPrimitiveFlagsStride = displacedMicromapPrimitiveFlagsStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setBaseTriangle( uint32_t baseTriangle_ ) & VULKAN_HPP_NOEXCEPT
    {
      baseTriangle = baseTriangle_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setBaseTriangle( uint32_t baseTriangle_ ) && VULKAN_HPP_NOEXCEPT
    {
      baseTriangle = baseTriangle_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = usageCountsCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = usageCountsCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setPUsageCounts( MicromapUsageEXT const * pUsageCounts_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pUsageCounts = pUsageCounts_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setPUsageCounts( MicromapUsageEXT const * pUsageCounts_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pUsageCounts = pUsageCounts_;
      return std::move( *this );
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureTrianglesDisplacementMicromapNV &
      setUsageCounts( ArrayProxyNoTemporaries<MicromapUsageEXT const> const & usageCounts_ ) VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = static_cast<uint32_t>( usageCounts_.size() );
      pUsageCounts     = usageCounts_.data();
      return *this;
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setPpUsageCounts( MicromapUsageEXT const * const * ppUsageCounts_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      ppUsageCounts = ppUsageCounts_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setPpUsageCounts( MicromapUsageEXT const * const * ppUsageCounts_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      ppUsageCounts = ppUsageCounts_;
      return std::move( *this );
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureTrianglesDisplacementMicromapNV &
      setPUsageCounts( ArrayProxyNoTemporaries<MicromapUsageEXT const * const> const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = static_cast<uint32_t>( pUsageCounts_.size() );
      ppUsageCounts    = pUsageCounts_.data();
      return *this;
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setMicromap( MicromapEXT micromap_ ) & VULKAN_HPP_NOEXCEPT
    {
      micromap = micromap_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setMicromap( MicromapEXT micromap_ ) && VULKAN_HPP_NOEXCEPT
    {
      micromap = micromap_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureTrianglesDisplacementMicromapNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV const *>( this );
    }

    operator VkAccelerationStructureTrianglesDisplacementMicromapNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV *>( this );
    }

    operator VkAccelerationStructureTrianglesDisplacementMicromapNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV const *>( this );
    }

    operator VkAccelerationStructureTrianglesDisplacementMicromapNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               Format const &,
               Format const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               IndexType const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               uint32_t const &,
               uint32_t const &,
               MicromapUsageEXT const * const &,
               MicromapUsageEXT const * const * const &,
               MicromapEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       displacementBiasAndScaleFormat,
                       displacementVectorFormat,
                       displacementBiasAndScaleBuffer,
                       displacementBiasAndScaleStride,
                       displacementVectorBuffer,
                       displacementVectorStride,
                       displacedMicromapPrimitiveFlags,
                       displacedMicromapPrimitiveFlagsStride,
                       indexType,
                       indexBuffer,
                       indexStride,
                       baseTriangle,
                       usageCountsCount,
                       pUsageCounts,
                       ppUsageCounts,
                       micromap );
    }
#  endif

  public:
    StructureType                    sType                                 = StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV;
    void *                           pNext                                 = {};
    Format                           displacementBiasAndScaleFormat        = Format::eUndefined;
    Format                           displacementVectorFormat              = Format::eUndefined;
    DeviceOrHostAddressConstKHR      displacementBiasAndScaleBuffer        = {};
    DeviceSize                       displacementBiasAndScaleStride        = {};
    DeviceOrHostAddressConstKHR      displacementVectorBuffer              = {};
    DeviceSize                       displacementVectorStride              = {};
    DeviceOrHostAddressConstKHR      displacedMicromapPrimitiveFlags       = {};
    DeviceSize                       displacedMicromapPrimitiveFlagsStride = {};
    IndexType                        indexType                             = IndexType::eUint16;
    DeviceOrHostAddressConstKHR      indexBuffer                           = {};
    DeviceSize                       indexStride                           = {};
    uint32_t                         baseTriangle                          = {};
    uint32_t                         usageCountsCount                      = {};
    MicromapUsageEXT const *         pUsageCounts                          = {};
    MicromapUsageEXT const * const * ppUsageCounts                         = {};
    MicromapEXT                      micromap                              = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureTrianglesDisplacementMicromapNV>
  {
    using Type = AccelerationStructureTrianglesDisplacementMicromapNV;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV>
  {
    using Type = AccelerationStructureTrianglesDisplacementMicromapNV;
  };
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

  // wrapper struct for struct VkAccelerationStructureTrianglesOpacityMicromapEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesOpacityMicromapEXT.html
  struct AccelerationStructureTrianglesOpacityMicromapEXT
  {
    using NativeType = VkAccelerationStructureTrianglesOpacityMicromapEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT( IndexType                        indexType_        = IndexType::eUint16,
                                                                              DeviceOrHostAddressConstKHR      indexBuffer_      = {},
                                                                              DeviceSize                       indexStride_      = {},
                                                                              uint32_t                         baseTriangle_     = {},
                                                                              uint32_t                         usageCountsCount_ = {},
                                                                              MicromapUsageEXT const *         pUsageCounts_     = {},
                                                                              MicromapUsageEXT const * const * ppUsageCounts_    = {},
                                                                              MicromapEXT                      micromap_         = {},
                                                                              void *                           pNext_            = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , indexType{ indexType_ }
      , indexBuffer{ indexBuffer_ }
      , indexStride{ indexStride_ }
      , baseTriangle{ baseTriangle_ }
      , usageCountsCount{ usageCountsCount_ }
      , pUsageCounts{ pUsageCounts_ }
      , ppUsageCounts{ ppUsageCounts_ }
      , micromap{ micromap_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14
      AccelerationStructureTrianglesOpacityMicromapEXT( AccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureTrianglesOpacityMicromapEXT( VkAccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureTrianglesOpacityMicromapEXT( *reinterpret_cast<AccelerationStructureTrianglesOpacityMicromapEXT const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureTrianglesOpacityMicromapEXT( IndexType                                                       indexType_,
                                                      DeviceOrHostAddressConstKHR                                     indexBuffer_,
                                                      DeviceSize                                                      indexStride_,
                                                      uint32_t                                                        baseTriangle_,
                                                      ArrayProxyNoTemporaries<MicromapUsageEXT const> const &         usageCounts_,
                                                      ArrayProxyNoTemporaries<MicromapUsageEXT const * const> const & pUsageCounts_ = {},
                                                      MicromapEXT                                                     micromap_     = {},
                                                      void *                                                          pNext_        = nullptr )
      : pNext( pNext_ )
      , indexType( indexType_ )
      , indexBuffer( indexBuffer_ )
      , indexStride( indexStride_ )
      , baseTriangle( baseTriangle_ )
      , usageCountsCount( static_cast<uint32_t>( !usageCounts_.empty() ? usageCounts_.size() : pUsageCounts_.size() ) )
      , pUsageCounts( usageCounts_.data() )
      , ppUsageCounts( pUsageCounts_.data() )
      , micromap( micromap_ )
    {
#    ifdef VULKAN_HPP_NO_EXCEPTIONS
      VULKAN_HPP_ASSERT( ( !usageCounts_.empty() + !pUsageCounts_.empty() ) <= 1 );
#    else
      if ( 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() ) )
      {
        throw LogicError(
          VULKAN_HPP_NAMESPACE_STRING
          "::AccelerationStructureTrianglesOpacityMicromapEXT::AccelerationStructureTrianglesOpacityMicromapEXT: 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() )" );
      }
#    endif /*VULKAN_HPP_NO_EXCEPTIONS*/
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    AccelerationStructureTrianglesOpacityMicromapEXT & operator=( AccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureTrianglesOpacityMicromapEXT & operator=( VkAccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureTrianglesOpacityMicromapEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setBaseTriangle( uint32_t baseTriangle_ ) & VULKAN_HPP_NOEXCEPT
    {
      baseTriangle = baseTriangle_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setBaseTriangle( uint32_t baseTriangle_ ) && VULKAN_HPP_NOEXCEPT
    {
      baseTriangle = baseTriangle_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = usageCountsCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = usageCountsCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setPUsageCounts( MicromapUsageEXT const * pUsageCounts_ ) & VULKAN_HPP_NOEXCEPT
    {
      pUsageCounts = pUsageCounts_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setPUsageCounts( MicromapUsageEXT const * pUsageCounts_ ) && VULKAN_HPP_NOEXCEPT
    {
      pUsageCounts = pUsageCounts_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureTrianglesOpacityMicromapEXT &
      setUsageCounts( ArrayProxyNoTemporaries<MicromapUsageEXT const> const & usageCounts_ ) VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = static_cast<uint32_t>( usageCounts_.size() );
      pUsageCounts     = usageCounts_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setPpUsageCounts( MicromapUsageEXT const * const * ppUsageCounts_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      ppUsageCounts = ppUsageCounts_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setPpUsageCounts( MicromapUsageEXT const * const * ppUsageCounts_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      ppUsageCounts = ppUsageCounts_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AccelerationStructureTrianglesOpacityMicromapEXT &
      setPUsageCounts( ArrayProxyNoTemporaries<MicromapUsageEXT const * const> const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT
    {
      usageCountsCount = static_cast<uint32_t>( pUsageCounts_.size() );
      ppUsageCounts    = pUsageCounts_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setMicromap( MicromapEXT micromap_ ) & VULKAN_HPP_NOEXCEPT
    {
      micromap = micromap_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setMicromap( MicromapEXT micromap_ ) && VULKAN_HPP_NOEXCEPT
    {
      micromap = micromap_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureTrianglesOpacityMicromapEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT const *>( this );
    }

    operator VkAccelerationStructureTrianglesOpacityMicromapEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT *>( this );
    }

    operator VkAccelerationStructureTrianglesOpacityMicromapEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT const *>( this );
    }

    operator VkAccelerationStructureTrianglesOpacityMicromapEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               IndexType const &,
               DeviceOrHostAddressConstKHR const &,
               DeviceSize const &,
               uint32_t const &,
               uint32_t const &,
               MicromapUsageEXT const * const &,
               MicromapUsageEXT const * const * const &,
               MicromapEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, indexType, indexBuffer, indexStride, baseTriangle, usageCountsCount, pUsageCounts, ppUsageCounts, micromap );
    }
#endif

  public:
    StructureType                    sType            = StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT;
    void *                           pNext            = {};
    IndexType                        indexType        = IndexType::eUint16;
    DeviceOrHostAddressConstKHR      indexBuffer      = {};
    DeviceSize                       indexStride      = {};
    uint32_t                         baseTriangle     = {};
    uint32_t                         usageCountsCount = {};
    MicromapUsageEXT const *         pUsageCounts     = {};
    MicromapUsageEXT const * const * ppUsageCounts    = {};
    MicromapEXT                      micromap         = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureTrianglesOpacityMicromapEXT>
  {
    using Type = AccelerationStructureTrianglesOpacityMicromapEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT>
  {
    using Type = AccelerationStructureTrianglesOpacityMicromapEXT;
  };

  // wrapper struct for struct VkAccelerationStructureTrianglesOpacityMicromapKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesOpacityMicromapKHR.html
  struct AccelerationStructureTrianglesOpacityMicromapKHR
  {
    using NativeType = VkAccelerationStructureTrianglesOpacityMicromapKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureTrianglesOpacityMicromapKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureTrianglesOpacityMicromapKHR( IndexType                indexType_    = IndexType::eUint16,
                                                                           DeviceAddress            indexBuffer_  = {},
                                                                           DeviceSize               indexStride_  = {},
                                                                           uint32_t                 baseTriangle_ = {},
                                                                           AccelerationStructureKHR micromap_     = {},
                                                                           void *                   pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , indexType{ indexType_ }
      , indexBuffer{ indexBuffer_ }
      , indexStride{ indexStride_ }
      , baseTriangle{ baseTriangle_ }
      , micromap{ micromap_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      AccelerationStructureTrianglesOpacityMicromapKHR( AccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureTrianglesOpacityMicromapKHR( VkAccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureTrianglesOpacityMicromapKHR( *reinterpret_cast<AccelerationStructureTrianglesOpacityMicromapKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureTrianglesOpacityMicromapKHR & operator=( AccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureTrianglesOpacityMicromapKHR & operator=( VkAccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureTrianglesOpacityMicromapKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setIndexBuffer( DeviceAddress indexBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setIndexBuffer( DeviceAddress indexBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexStride = indexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setBaseTriangle( uint32_t baseTriangle_ ) & VULKAN_HPP_NOEXCEPT
    {
      baseTriangle = baseTriangle_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setBaseTriangle( uint32_t baseTriangle_ ) && VULKAN_HPP_NOEXCEPT
    {
      baseTriangle = baseTriangle_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setMicromap( AccelerationStructureKHR micromap_ ) & VULKAN_HPP_NOEXCEPT
    {
      micromap = micromap_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setMicromap( AccelerationStructureKHR micromap_ ) && VULKAN_HPP_NOEXCEPT
    {
      micromap = micromap_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureTrianglesOpacityMicromapKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapKHR const *>( this );
    }

    operator VkAccelerationStructureTrianglesOpacityMicromapKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapKHR *>( this );
    }

    operator VkAccelerationStructureTrianglesOpacityMicromapKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapKHR const *>( this );
    }

    operator VkAccelerationStructureTrianglesOpacityMicromapKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               IndexType const &,
               DeviceAddress const &,
               DeviceSize const &,
               uint32_t const &,
               AccelerationStructureKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, indexType, indexBuffer, indexStride, baseTriangle, micromap );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureTrianglesOpacityMicromapKHR const & ) const = default;
#else
    bool operator==( AccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexType == rhs.indexType ) && ( indexBuffer == rhs.indexBuffer ) &&
             ( indexStride == rhs.indexStride ) && ( baseTriangle == rhs.baseTriangle ) && ( micromap == rhs.micromap );
#  endif
    }

    bool operator!=( AccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType            sType        = StructureType::eAccelerationStructureTrianglesOpacityMicromapKHR;
    void *                   pNext        = {};
    IndexType                indexType    = IndexType::eUint16;
    DeviceAddress            indexBuffer  = {};
    DeviceSize               indexStride  = {};
    uint32_t                 baseTriangle = {};
    AccelerationStructureKHR micromap     = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureTrianglesOpacityMicromapKHR>
  {
    using Type = AccelerationStructureTrianglesOpacityMicromapKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureTrianglesOpacityMicromapKHR>
  {
    using Type = AccelerationStructureTrianglesOpacityMicromapKHR;
  };

  // wrapper struct for struct VkAccelerationStructureVersionInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureVersionInfoKHR.html
  struct AccelerationStructureVersionInfoKHR
  {
    using NativeType = VkAccelerationStructureVersionInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAccelerationStructureVersionInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AccelerationStructureVersionInfoKHR( uint8_t const * pVersionData_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pVersionData{ pVersionData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AccelerationStructureVersionInfoKHR( AccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AccelerationStructureVersionInfoKHR( VkAccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AccelerationStructureVersionInfoKHR( *reinterpret_cast<AccelerationStructureVersionInfoKHR const *>( &rhs ) )
    {
    }

    AccelerationStructureVersionInfoKHR & operator=( AccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AccelerationStructureVersionInfoKHR & operator=( VkAccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AccelerationStructureVersionInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR & setPVersionData( uint8_t const * pVersionData_ ) & VULKAN_HPP_NOEXCEPT
    {
      pVersionData = pVersionData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR && setPVersionData( uint8_t const * pVersionData_ ) && VULKAN_HPP_NOEXCEPT
    {
      pVersionData = pVersionData_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureVersionInfoKHR const *>( this );
    }

    operator VkAccelerationStructureVersionInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAccelerationStructureVersionInfoKHR *>( this );
    }

    operator VkAccelerationStructureVersionInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureVersionInfoKHR const *>( this );
    }

    operator VkAccelerationStructureVersionInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAccelerationStructureVersionInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint8_t const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pVersionData );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AccelerationStructureVersionInfoKHR const & ) const = default;
#else
    bool operator==( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData );
#  endif
    }

    bool operator!=( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType   sType        = StructureType::eAccelerationStructureVersionInfoKHR;
    void const *    pNext        = {};
    uint8_t const * pVersionData = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAccelerationStructureVersionInfoKHR>
  {
    using Type = AccelerationStructureVersionInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAccelerationStructureVersionInfoKHR>
  {
    using Type = AccelerationStructureVersionInfoKHR;
  };

  // wrapper struct for struct VkAcquireNextImageInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireNextImageInfoKHR.html
  struct AcquireNextImageInfoKHR
  {
    using NativeType = VkAcquireNextImageInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAcquireNextImageInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( SwapchainKHR swapchain_  = {},
                                                  uint64_t     timeout_    = {},
                                                  Semaphore    semaphore_  = {},
                                                  Fence        fence_      = {},
                                                  uint32_t     deviceMask_ = {},
                                                  void const * pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , swapchain{ swapchain_ }
      , timeout{ timeout_ }
      , semaphore{ semaphore_ }
      , fence{ fence_ }
      , deviceMask{ deviceMask_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AcquireNextImageInfoKHR( *reinterpret_cast<AcquireNextImageInfoKHR const *>( &rhs ) )
    {
    }

    AcquireNextImageInfoKHR & operator=( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AcquireNextImageInfoKHR & operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AcquireNextImageInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT
    {
      swapchain = swapchain_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT
    {
      swapchain = swapchain_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setTimeout( uint64_t timeout_ ) & VULKAN_HPP_NOEXCEPT
    {
      timeout = timeout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setTimeout( uint64_t timeout_ ) && VULKAN_HPP_NOEXCEPT
    {
      timeout = timeout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT
    {
      semaphore = semaphore_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT
    {
      semaphore = semaphore_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT
    {
      fence = fence_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT
    {
      fence = fence_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceMask = deviceMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceMask = deviceMask_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAcquireNextImageInfoKHR const *>( this );
    }

    operator VkAcquireNextImageInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAcquireNextImageInfoKHR *>( this );
    }

    operator VkAcquireNextImageInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAcquireNextImageInfoKHR const *>( this );
    }

    operator VkAcquireNextImageInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAcquireNextImageInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, SwapchainKHR const &, uint64_t const &, Semaphore const &, Fence const &, uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AcquireNextImageInfoKHR const & ) const = default;
#else
    bool operator==( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( timeout == rhs.timeout ) &&
             ( semaphore == rhs.semaphore ) && ( fence == rhs.fence ) && ( deviceMask == rhs.deviceMask );
#  endif
    }

    bool operator!=( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType      = StructureType::eAcquireNextImageInfoKHR;
    void const *  pNext      = {};
    SwapchainKHR  swapchain  = {};
    uint64_t      timeout    = {};
    Semaphore     semaphore  = {};
    Fence         fence      = {};
    uint32_t      deviceMask = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAcquireNextImageInfoKHR>
  {
    using Type = AcquireNextImageInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAcquireNextImageInfoKHR>
  {
    using Type = AcquireNextImageInfoKHR;
  };

  // wrapper struct for struct VkAcquireProfilingLockInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireProfilingLockInfoKHR.html
  struct AcquireProfilingLockInfoKHR
  {
    using NativeType = VkAcquireProfilingLockInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAcquireProfilingLockInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      AcquireProfilingLockInfoKHR( AcquireProfilingLockFlagsKHR flags_ = {}, uint64_t timeout_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , timeout{ timeout_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AcquireProfilingLockInfoKHR( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AcquireProfilingLockInfoKHR( *reinterpret_cast<AcquireProfilingLockInfoKHR const *>( &rhs ) )
    {
    }

    AcquireProfilingLockInfoKHR & operator=( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AcquireProfilingLockInfoKHR & operator=( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AcquireProfilingLockInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR & setFlags( AcquireProfilingLockFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR && setFlags( AcquireProfilingLockFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR & setTimeout( uint64_t timeout_ ) & VULKAN_HPP_NOEXCEPT
    {
      timeout = timeout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR && setTimeout( uint64_t timeout_ ) && VULKAN_HPP_NOEXCEPT
    {
      timeout = timeout_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAcquireProfilingLockInfoKHR const *>( this );
    }

    operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAcquireProfilingLockInfoKHR *>( this );
    }

    operator VkAcquireProfilingLockInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAcquireProfilingLockInfoKHR const *>( this );
    }

    operator VkAcquireProfilingLockInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAcquireProfilingLockInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, AcquireProfilingLockFlagsKHR const &, uint64_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, timeout );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AcquireProfilingLockInfoKHR const & ) const = default;
#else
    bool operator==( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout );
#  endif
    }

    bool operator!=( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                sType   = StructureType::eAcquireProfilingLockInfoKHR;
    void const *                 pNext   = {};
    AcquireProfilingLockFlagsKHR flags   = {};
    uint64_t                     timeout = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAcquireProfilingLockInfoKHR>
  {
    using Type = AcquireProfilingLockInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAcquireProfilingLockInfoKHR>
  {
    using Type = AcquireProfilingLockInfoKHR;
  };

  typedef void *( VKAPI_PTR * PFN_AllocationFunction )( void * pUserData, size_t size, size_t alignment, SystemAllocationScope allocationScope );

  typedef void *( VKAPI_PTR *
                  PFN_ReallocationFunction )( void * pUserData, void * pOriginal, size_t size, size_t alignment, SystemAllocationScope allocationScope );

  typedef void( VKAPI_PTR * PFN_FreeFunction )( void * pUserData, void * pMemory );

  typedef void( VKAPI_PTR * PFN_InternalAllocationNotification )(
    void * pUserData, size_t size, InternalAllocationType allocationType, SystemAllocationScope allocationScope );

  typedef void( VKAPI_PTR *
                PFN_InternalFreeNotification )( void * pUserData, size_t size, InternalAllocationType allocationType, SystemAllocationScope allocationScope );

  // wrapper struct for struct VkAllocationCallbacks, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAllocationCallbacks.html
  struct AllocationCallbacks
  {
    using NativeType = VkAllocationCallbacks;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AllocationCallbacks( void *                             pUserData_             = {},
                                              PFN_AllocationFunction             pfnAllocation_         = {},
                                              PFN_ReallocationFunction           pfnReallocation_       = {},
                                              PFN_FreeFunction                   pfnFree_               = {},
                                              PFN_InternalAllocationNotification pfnInternalAllocation_ = {},
                                              PFN_InternalFreeNotification       pfnInternalFree_       = {} ) VULKAN_HPP_NOEXCEPT
      : pUserData{ pUserData_ }
      , pfnAllocation{ pfnAllocation_ }
      , pfnReallocation{ pfnReallocation_ }
      , pfnFree{ pfnFree_ }
      , pfnInternalAllocation{ pfnInternalAllocation_ }
      , pfnInternalFree{ pfnInternalFree_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AllocationCallbacks( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AllocationCallbacks( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT : AllocationCallbacks( *reinterpret_cast<AllocationCallbacks const *>( &rhs ) )
    {
    }

#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic push
#    if defined( __clang__ )
#      pragma clang diagnostic ignored "-Wunknown-warning-option"
#    endif
#    pragma GCC diagnostic ignored "-Wcast-function-type"
#  endif
    VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." )

    AllocationCallbacks( void *                               pUserData_,
                         PFN_vkAllocationFunction             pfnAllocation_,
                         PFN_vkReallocationFunction           pfnReallocation_       = {},
                         PFN_vkFreeFunction                   pfnFree_               = {},
                         PFN_vkInternalAllocationNotification pfnInternalAllocation_ = {},
                         PFN_vkInternalFreeNotification       pfnInternalFree_       = {} ) VULKAN_HPP_NOEXCEPT
      : AllocationCallbacks( pUserData_,
                             reinterpret_cast<PFN_AllocationFunction>( pfnAllocation_ ),
                             reinterpret_cast<PFN_ReallocationFunction>( pfnReallocation_ ),
                             reinterpret_cast<PFN_FreeFunction>( pfnFree_ ),
                             reinterpret_cast<PFN_InternalAllocationNotification>( pfnInternalAllocation_ ),
                             reinterpret_cast<PFN_InternalFreeNotification>( pfnInternalFree_ ) )
    {
    }
#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic pop
#  endif

    AllocationCallbacks & operator=( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AllocationCallbacks & operator=( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AllocationCallbacks const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT
    {
      pUserData = pUserData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT
    {
      pUserData = pUserData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnAllocation( PFN_AllocationFunction pfnAllocation_ ) & VULKAN_HPP_NOEXCEPT
    {
      pfnAllocation = pfnAllocation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnAllocation( PFN_AllocationFunction pfnAllocation_ ) && VULKAN_HPP_NOEXCEPT
    {
      pfnAllocation = pfnAllocation_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnReallocation( PFN_ReallocationFunction pfnReallocation_ ) & VULKAN_HPP_NOEXCEPT
    {
      pfnReallocation = pfnReallocation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnReallocation( PFN_ReallocationFunction pfnReallocation_ ) && VULKAN_HPP_NOEXCEPT
    {
      pfnReallocation = pfnReallocation_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnFree( PFN_FreeFunction pfnFree_ ) & VULKAN_HPP_NOEXCEPT
    {
      pfnFree = pfnFree_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnFree( PFN_FreeFunction pfnFree_ ) && VULKAN_HPP_NOEXCEPT
    {
      pfnFree = pfnFree_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalAllocation( PFN_InternalAllocationNotification pfnInternalAllocation_ ) & VULKAN_HPP_NOEXCEPT
    {
      pfnInternalAllocation = pfnInternalAllocation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnInternalAllocation( PFN_InternalAllocationNotification pfnInternalAllocation_ ) && VULKAN_HPP_NOEXCEPT
    {
      pfnInternalAllocation = pfnInternalAllocation_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalFree( PFN_InternalFreeNotification pfnInternalFree_ ) & VULKAN_HPP_NOEXCEPT
    {
      pfnInternalFree = pfnInternalFree_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnInternalFree( PFN_InternalFreeNotification pfnInternalFree_ ) && VULKAN_HPP_NOEXCEPT
    {
      pfnInternalFree = pfnInternalFree_;
      return std::move( *this );
    }

#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic push
#    if defined( __clang__ )
#      pragma clang diagnostic ignored "-Wunknown-warning-option"
#    endif
#    pragma GCC diagnostic ignored "-Wcast-function-type"
#  endif
    VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )

    AllocationCallbacks & setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT
    {
      return setPfnAllocation( reinterpret_cast<PFN_AllocationFunction>( pfnAllocation_ ) );
    }

    VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )

    AllocationCallbacks & setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT
    {
      return setPfnReallocation( reinterpret_cast<PFN_ReallocationFunction>( pfnReallocation_ ) );
    }

    VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )

    AllocationCallbacks & setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT
    {
      return setPfnInternalAllocation( reinterpret_cast<PFN_InternalAllocationNotification>( pfnInternalAllocation_ ) );
    }

    VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )

    AllocationCallbacks & setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT
    {
      return setPfnInternalFree( reinterpret_cast<PFN_InternalFreeNotification>( pfnInternalFree_ ) );
    }
#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic pop
#  endif
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAllocationCallbacks const *>( this );
    }

    operator VkAllocationCallbacks &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAllocationCallbacks *>( this );
    }

    operator VkAllocationCallbacks const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAllocationCallbacks const *>( this );
    }

    operator VkAllocationCallbacks *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAllocationCallbacks *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<void * const &,
               PFN_AllocationFunction const &,
               PFN_ReallocationFunction const &,
               PFN_FreeFunction const &,
               PFN_InternalAllocationNotification const &,
               PFN_InternalFreeNotification const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( pUserData, pfnAllocation, pfnReallocation, pfnFree, pfnInternalAllocation, pfnInternalFree );
    }
#endif

    bool operator==( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#else
      return ( pUserData == rhs.pUserData ) && ( pfnAllocation == rhs.pfnAllocation ) && ( pfnReallocation == rhs.pfnReallocation ) &&
             ( pfnFree == rhs.pfnFree ) && ( pfnInternalAllocation == rhs.pfnInternalAllocation ) && ( pfnInternalFree == rhs.pfnInternalFree );
#endif
    }

    bool operator!=( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    void *                             pUserData             = {};
    PFN_AllocationFunction             pfnAllocation         = {};
    PFN_ReallocationFunction           pfnReallocation       = {};
    PFN_FreeFunction                   pfnFree               = {};
    PFN_InternalAllocationNotification pfnInternalAllocation = {};
    PFN_InternalFreeNotification       pfnInternalFree       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAllocationCallbacks>
  {
    using Type = AllocationCallbacks;
  };
#endif

  // wrapper struct for struct VkAmigoProfilingSubmitInfoSEC, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAmigoProfilingSubmitInfoSEC.html
  struct AmigoProfilingSubmitInfoSEC
  {
    using NativeType = VkAmigoProfilingSubmitInfoSEC;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAmigoProfilingSubmitInfoSEC;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      AmigoProfilingSubmitInfoSEC( uint64_t firstDrawTimestamp_ = {}, uint64_t swapBufferTimestamp_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , firstDrawTimestamp{ firstDrawTimestamp_ }
      , swapBufferTimestamp{ swapBufferTimestamp_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AmigoProfilingSubmitInfoSEC( AmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AmigoProfilingSubmitInfoSEC( VkAmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT
      : AmigoProfilingSubmitInfoSEC( *reinterpret_cast<AmigoProfilingSubmitInfoSEC const *>( &rhs ) )
    {
    }

    AmigoProfilingSubmitInfoSEC & operator=( AmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AmigoProfilingSubmitInfoSEC & operator=( VkAmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AmigoProfilingSubmitInfoSEC const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC & setFirstDrawTimestamp( uint64_t firstDrawTimestamp_ ) & VULKAN_HPP_NOEXCEPT
    {
      firstDrawTimestamp = firstDrawTimestamp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC && setFirstDrawTimestamp( uint64_t firstDrawTimestamp_ ) && VULKAN_HPP_NOEXCEPT
    {
      firstDrawTimestamp = firstDrawTimestamp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC & setSwapBufferTimestamp( uint64_t swapBufferTimestamp_ ) & VULKAN_HPP_NOEXCEPT
    {
      swapBufferTimestamp = swapBufferTimestamp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC && setSwapBufferTimestamp( uint64_t swapBufferTimestamp_ ) && VULKAN_HPP_NOEXCEPT
    {
      swapBufferTimestamp = swapBufferTimestamp_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAmigoProfilingSubmitInfoSEC const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAmigoProfilingSubmitInfoSEC const *>( this );
    }

    operator VkAmigoProfilingSubmitInfoSEC &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAmigoProfilingSubmitInfoSEC *>( this );
    }

    operator VkAmigoProfilingSubmitInfoSEC const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAmigoProfilingSubmitInfoSEC const *>( this );
    }

    operator VkAmigoProfilingSubmitInfoSEC *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAmigoProfilingSubmitInfoSEC *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint64_t const &, uint64_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, firstDrawTimestamp, swapBufferTimestamp );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AmigoProfilingSubmitInfoSEC const & ) const = default;
#else
    bool operator==( AmigoProfilingSubmitInfoSEC const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( firstDrawTimestamp == rhs.firstDrawTimestamp ) &&
             ( swapBufferTimestamp == rhs.swapBufferTimestamp );
#  endif
    }

    bool operator!=( AmigoProfilingSubmitInfoSEC const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType               = StructureType::eAmigoProfilingSubmitInfoSEC;
    void const *  pNext               = {};
    uint64_t      firstDrawTimestamp  = {};
    uint64_t      swapBufferTimestamp = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAmigoProfilingSubmitInfoSEC>
  {
    using Type = AmigoProfilingSubmitInfoSEC;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAmigoProfilingSubmitInfoSEC>
  {
    using Type = AmigoProfilingSubmitInfoSEC;
  };

  // wrapper struct for struct VkComponentMapping, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentMapping.html
  struct ComponentMapping
  {
    using NativeType = VkComponentMapping;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity,
                                           ComponentSwizzle g_ = ComponentSwizzle::eIdentity,
                                           ComponentSwizzle b_ = ComponentSwizzle::eIdentity,
                                           ComponentSwizzle a_ = ComponentSwizzle::eIdentity ) VULKAN_HPP_NOEXCEPT
      : r{ r_ }
      , g{ g_ }
      , b{ b_ }
      , a{ a_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ComponentMapping( ComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ComponentMapping( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT : ComponentMapping( *reinterpret_cast<ComponentMapping const *>( &rhs ) ) {}

    ComponentMapping & operator=( ComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ComponentMapping & operator=( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ComponentMapping const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setR( ComponentSwizzle r_ ) & VULKAN_HPP_NOEXCEPT
    {
      r = r_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setR( ComponentSwizzle r_ ) && VULKAN_HPP_NOEXCEPT
    {
      r = r_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setG( ComponentSwizzle g_ ) & VULKAN_HPP_NOEXCEPT
    {
      g = g_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setG( ComponentSwizzle g_ ) && VULKAN_HPP_NOEXCEPT
    {
      g = g_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setB( ComponentSwizzle b_ ) & VULKAN_HPP_NOEXCEPT
    {
      b = b_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setB( ComponentSwizzle b_ ) && VULKAN_HPP_NOEXCEPT
    {
      b = b_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setA( ComponentSwizzle a_ ) & VULKAN_HPP_NOEXCEPT
    {
      a = a_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setA( ComponentSwizzle a_ ) && VULKAN_HPP_NOEXCEPT
    {
      a = a_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkComponentMapping const *>( this );
    }

    operator VkComponentMapping &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkComponentMapping *>( this );
    }

    operator VkComponentMapping const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkComponentMapping const *>( this );
    }

    operator VkComponentMapping *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkComponentMapping *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<ComponentSwizzle const &, ComponentSwizzle const &, ComponentSwizzle const &, ComponentSwizzle const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( r, g, b, a );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ComponentMapping const & ) const = default;
#else
    bool operator==( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( r == rhs.r ) && ( g == rhs.g ) && ( b == rhs.b ) && ( a == rhs.a );
#  endif
    }

    bool operator!=( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    ComponentSwizzle r = ComponentSwizzle::eIdentity;
    ComponentSwizzle g = ComponentSwizzle::eIdentity;
    ComponentSwizzle b = ComponentSwizzle::eIdentity;
    ComponentSwizzle a = ComponentSwizzle::eIdentity;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkComponentMapping>
  {
    using Type = ComponentMapping;
  };
#endif

#if defined( VK_USE_PLATFORM_ANDROID_KHR )
  // wrapper struct for struct VkAndroidHardwareBufferFormatProperties2ANDROID, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatProperties2ANDROID.html
  struct AndroidHardwareBufferFormatProperties2ANDROID
  {
    using NativeType = VkAndroidHardwareBufferFormatProperties2ANDROID;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAndroidHardwareBufferFormatProperties2ANDROID;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      AndroidHardwareBufferFormatProperties2ANDROID( Format                      format_                           = Format::eUndefined,
                                                     uint64_t                    externalFormat_                   = {},
                                                     FormatFeatureFlags2         formatFeatures_                   = {},
                                                     ComponentMapping            samplerYcbcrConversionComponents_ = {},
                                                     SamplerYcbcrModelConversion suggestedYcbcrModel_              = SamplerYcbcrModelConversion::eRgbIdentity,
                                                     SamplerYcbcrRange           suggestedYcbcrRange_              = SamplerYcbcrRange::eItuFull,
                                                     ChromaLocation              suggestedXChromaOffset_           = ChromaLocation::eCositedEven,
                                                     ChromaLocation              suggestedYChromaOffset_           = ChromaLocation::eCositedEven,
                                                     void *                      pNext_                            = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , format{ format_ }
      , externalFormat{ externalFormat_ }
      , formatFeatures{ formatFeatures_ }
      , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ }
      , suggestedYcbcrModel{ suggestedYcbcrModel_ }
      , suggestedYcbcrRange{ suggestedYcbcrRange_ }
      , suggestedXChromaOffset{ suggestedXChromaOffset_ }
      , suggestedYChromaOffset{ suggestedYChromaOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      AndroidHardwareBufferFormatProperties2ANDROID( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AndroidHardwareBufferFormatProperties2ANDROID( VkAndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
      : AndroidHardwareBufferFormatProperties2ANDROID( *reinterpret_cast<AndroidHardwareBufferFormatProperties2ANDROID const *>( &rhs ) )
    {
    }

    AndroidHardwareBufferFormatProperties2ANDROID & operator=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AndroidHardwareBufferFormatProperties2ANDROID & operator=( VkAndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AndroidHardwareBufferFormatProperties2ANDROID const *>( &rhs );
      return *this;
    }

    operator VkAndroidHardwareBufferFormatProperties2ANDROID const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferFormatProperties2ANDROID &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID *>( this );
    }

    operator VkAndroidHardwareBufferFormatProperties2ANDROID const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferFormatProperties2ANDROID *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               Format const &,
               uint64_t const &,
               FormatFeatureFlags2 const &,
               ComponentMapping const &,
               SamplerYcbcrModelConversion const &,
               SamplerYcbcrRange const &,
               ChromaLocation const &,
               ChromaLocation const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       format,
                       externalFormat,
                       formatFeatures,
                       samplerYcbcrConversionComponents,
                       suggestedYcbcrModel,
                       suggestedYcbcrRange,
                       suggestedXChromaOffset,
                       suggestedYChromaOffset );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AndroidHardwareBufferFormatProperties2ANDROID const & ) const = default;
#  else
    bool operator==( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) &&
             ( formatFeatures == rhs.formatFeatures ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
             ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
             ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
#    endif
    }

    bool operator!=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType               sType                            = StructureType::eAndroidHardwareBufferFormatProperties2ANDROID;
    void *                      pNext                            = {};
    Format                      format                           = Format::eUndefined;
    uint64_t                    externalFormat                   = {};
    FormatFeatureFlags2         formatFeatures                   = {};
    ComponentMapping            samplerYcbcrConversionComponents = {};
    SamplerYcbcrModelConversion suggestedYcbcrModel              = SamplerYcbcrModelConversion::eRgbIdentity;
    SamplerYcbcrRange           suggestedYcbcrRange              = SamplerYcbcrRange::eItuFull;
    ChromaLocation              suggestedXChromaOffset           = ChromaLocation::eCositedEven;
    ChromaLocation              suggestedYChromaOffset           = ChromaLocation::eCositedEven;
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAndroidHardwareBufferFormatProperties2ANDROID>
  {
    using Type = AndroidHardwareBufferFormatProperties2ANDROID;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eAndroidHardwareBufferFormatProperties2ANDROID>
  {
    using Type = AndroidHardwareBufferFormatProperties2ANDROID;
  };
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#if defined( VK_USE_PLATFORM_ANDROID_KHR )
  // wrapper struct for struct VkAndroidHardwareBufferFormatPropertiesANDROID, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html
  struct AndroidHardwareBufferFormatPropertiesANDROID
  {
    using NativeType = VkAndroidHardwareBufferFormatPropertiesANDROID;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      AndroidHardwareBufferFormatPropertiesANDROID( Format                      format_                           = Format::eUndefined,
                                                    uint64_t                    externalFormat_                   = {},
                                                    FormatFeatureFlags          formatFeatures_                   = {},
                                                    ComponentMapping            samplerYcbcrConversionComponents_ = {},
                                                    SamplerYcbcrModelConversion suggestedYcbcrModel_              = SamplerYcbcrModelConversion::eRgbIdentity,
                                                    SamplerYcbcrRange           suggestedYcbcrRange_              = SamplerYcbcrRange::eItuFull,
                                                    ChromaLocation              suggestedXChromaOffset_           = ChromaLocation::eCositedEven,
                                                    ChromaLocation              suggestedYChromaOffset_           = ChromaLocation::eCositedEven,
                                                    void *                      pNext_                            = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , format{ format_ }
      , externalFormat{ externalFormat_ }
      , formatFeatures{ formatFeatures_ }
      , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ }
      , suggestedYcbcrModel{ suggestedYcbcrModel_ }
      , suggestedYcbcrRange{ suggestedYcbcrRange_ }
      , suggestedXChromaOffset{ suggestedXChromaOffset_ }
      , suggestedYChromaOffset{ suggestedYChromaOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatPropertiesANDROID( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
      : AndroidHardwareBufferFormatPropertiesANDROID( *reinterpret_cast<AndroidHardwareBufferFormatPropertiesANDROID const *>( &rhs ) )
    {
    }

    AndroidHardwareBufferFormatPropertiesANDROID & operator=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AndroidHardwareBufferFormatPropertiesANDROID & operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AndroidHardwareBufferFormatPropertiesANDROID const *>( &rhs );
      return *this;
    }

    operator VkAndroidHardwareBufferFormatPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferFormatPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID *>( this );
    }

    operator VkAndroidHardwareBufferFormatPropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferFormatPropertiesANDROID *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               Format const &,
               uint64_t const &,
               FormatFeatureFlags const &,
               ComponentMapping const &,
               SamplerYcbcrModelConversion const &,
               SamplerYcbcrRange const &,
               ChromaLocation const &,
               ChromaLocation const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       format,
                       externalFormat,
                       formatFeatures,
                       samplerYcbcrConversionComponents,
                       suggestedYcbcrModel,
                       suggestedYcbcrRange,
                       suggestedXChromaOffset,
                       suggestedYChromaOffset );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const & ) const = default;
#  else
    bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) &&
             ( formatFeatures == rhs.formatFeatures ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
             ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
             ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
#    endif
    }

    bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType               sType                            = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
    void *                      pNext                            = {};
    Format                      format                           = Format::eUndefined;
    uint64_t                    externalFormat                   = {};
    FormatFeatureFlags          formatFeatures                   = {};
    ComponentMapping            samplerYcbcrConversionComponents = {};
    SamplerYcbcrModelConversion suggestedYcbcrModel              = SamplerYcbcrModelConversion::eRgbIdentity;
    SamplerYcbcrRange           suggestedYcbcrRange              = SamplerYcbcrRange::eItuFull;
    ChromaLocation              suggestedXChromaOffset           = ChromaLocation::eCositedEven;
    ChromaLocation              suggestedYChromaOffset           = ChromaLocation::eCositedEven;
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAndroidHardwareBufferFormatPropertiesANDROID>
  {
    using Type = AndroidHardwareBufferFormatPropertiesANDROID;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eAndroidHardwareBufferFormatPropertiesANDROID>
  {
    using Type = AndroidHardwareBufferFormatPropertiesANDROID;
  };
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#if defined( VK_USE_PLATFORM_ANDROID_KHR )
  // wrapper struct for struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatResolvePropertiesANDROID.html
  struct AndroidHardwareBufferFormatResolvePropertiesANDROID
  {
    using NativeType = VkAndroidHardwareBufferFormatResolvePropertiesANDROID;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatResolvePropertiesANDROID( Format colorAttachmentFormat_ = Format::eUndefined,
                                                                              void * pNext_                 = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , colorAttachmentFormat{ colorAttachmentFormat_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      AndroidHardwareBufferFormatResolvePropertiesANDROID( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AndroidHardwareBufferFormatResolvePropertiesANDROID( VkAndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
      : AndroidHardwareBufferFormatResolvePropertiesANDROID( *reinterpret_cast<AndroidHardwareBufferFormatResolvePropertiesANDROID const *>( &rhs ) )
    {
    }

    AndroidHardwareBufferFormatResolvePropertiesANDROID &
      operator=( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AndroidHardwareBufferFormatResolvePropertiesANDROID & operator=( VkAndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AndroidHardwareBufferFormatResolvePropertiesANDROID const *>( &rhs );
      return *this;
    }

    operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferFormatResolvePropertiesANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>( this );
    }

    operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferFormatResolvePropertiesANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, Format const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, colorAttachmentFormat );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AndroidHardwareBufferFormatResolvePropertiesANDROID const & ) const = default;
#  else
    bool operator==( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentFormat == rhs.colorAttachmentFormat );
#    endif
    }

    bool operator!=( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType sType                 = StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID;
    void *        pNext                 = {};
    Format        colorAttachmentFormat = Format::eUndefined;
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>
  {
    using Type = AndroidHardwareBufferFormatResolvePropertiesANDROID;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID>
  {
    using Type = AndroidHardwareBufferFormatResolvePropertiesANDROID;
  };
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#if defined( VK_USE_PLATFORM_ANDROID_KHR )
  // wrapper struct for struct VkAndroidHardwareBufferPropertiesANDROID, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferPropertiesANDROID.html
  struct AndroidHardwareBufferPropertiesANDROID
  {
    using NativeType = VkAndroidHardwareBufferPropertiesANDROID;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAndroidHardwareBufferPropertiesANDROID;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      AndroidHardwareBufferPropertiesANDROID( DeviceSize allocationSize_ = {}, uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , allocationSize{ allocationSize_ }
      , memoryTypeBits{ memoryTypeBits_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AndroidHardwareBufferPropertiesANDROID( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
      : AndroidHardwareBufferPropertiesANDROID( *reinterpret_cast<AndroidHardwareBufferPropertiesANDROID const *>( &rhs ) )
    {
    }

    AndroidHardwareBufferPropertiesANDROID & operator=( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AndroidHardwareBufferPropertiesANDROID & operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AndroidHardwareBufferPropertiesANDROID const *>( &rhs );
      return *this;
    }

    operator VkAndroidHardwareBufferPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferPropertiesANDROID &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( this );
    }

    operator VkAndroidHardwareBufferPropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferPropertiesANDROID *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, DeviceSize const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, allocationSize, memoryTypeBits );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AndroidHardwareBufferPropertiesANDROID const & ) const = default;
#  else
    bool operator==( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeBits == rhs.memoryTypeBits );
#    endif
    }

    bool operator!=( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType sType          = StructureType::eAndroidHardwareBufferPropertiesANDROID;
    void *        pNext          = {};
    DeviceSize    allocationSize = {};
    uint32_t      memoryTypeBits = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAndroidHardwareBufferPropertiesANDROID>
  {
    using Type = AndroidHardwareBufferPropertiesANDROID;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eAndroidHardwareBufferPropertiesANDROID>
  {
    using Type = AndroidHardwareBufferPropertiesANDROID;
  };
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#if defined( VK_USE_PLATFORM_ANDROID_KHR )
  // wrapper struct for struct VkAndroidHardwareBufferUsageANDROID, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferUsageANDROID.html
  struct AndroidHardwareBufferUsageANDROID
  {
    using NativeType = VkAndroidHardwareBufferUsageANDROID;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAndroidHardwareBufferUsageANDROID;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , androidHardwareBufferUsage{ androidHardwareBufferUsage_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
      : AndroidHardwareBufferUsageANDROID( *reinterpret_cast<AndroidHardwareBufferUsageANDROID const *>( &rhs ) )
    {
    }

    AndroidHardwareBufferUsageANDROID & operator=( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AndroidHardwareBufferUsageANDROID & operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AndroidHardwareBufferUsageANDROID const *>( &rhs );
      return *this;
    }

    operator VkAndroidHardwareBufferUsageANDROID const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferUsageANDROID &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID *>( this );
    }

    operator VkAndroidHardwareBufferUsageANDROID const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID const *>( this );
    }

    operator VkAndroidHardwareBufferUsageANDROID *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, uint64_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, androidHardwareBufferUsage );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AndroidHardwareBufferUsageANDROID const & ) const = default;
#  else
    bool operator==( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage );
#    endif
    }

    bool operator!=( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType sType                      = StructureType::eAndroidHardwareBufferUsageANDROID;
    void *        pNext                      = {};
    uint64_t      androidHardwareBufferUsage = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAndroidHardwareBufferUsageANDROID>
  {
    using Type = AndroidHardwareBufferUsageANDROID;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eAndroidHardwareBufferUsageANDROID>
  {
    using Type = AndroidHardwareBufferUsageANDROID;
  };
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#if defined( VK_USE_PLATFORM_ANDROID_KHR )
  // wrapper struct for struct VkAndroidSurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidSurfaceCreateInfoKHR.html
  struct AndroidSurfaceCreateInfoKHR
  {
    using NativeType = VkAndroidSurfaceCreateInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAndroidSurfaceCreateInfoKHR;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_  = {},
                                                      struct ANativeWindow *       window_ = {},
                                                      void const *                 pNext_  = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , window{ window_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : AndroidSurfaceCreateInfoKHR( *reinterpret_cast<AndroidSurfaceCreateInfoKHR const *>( &rhs ) )
    {
    }

    AndroidSurfaceCreateInfoKHR & operator=( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AndroidSurfaceCreateInfoKHR & operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AndroidSurfaceCreateInfoKHR const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR & setFlags( AndroidSurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR && setFlags( AndroidSurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR & setWindow( struct ANativeWindow * window_ ) & VULKAN_HPP_NOEXCEPT
    {
      window = window_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR && setWindow( struct ANativeWindow * window_ ) && VULKAN_HPP_NOEXCEPT
    {
      window = window_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR const *>( this );
    }

    operator VkAndroidSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>( this );
    }

    operator VkAndroidSurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR const *>( this );
    }

    operator VkAndroidSurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, AndroidSurfaceCreateFlagsKHR const &, struct ANativeWindow * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, window );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AndroidSurfaceCreateInfoKHR const & ) const = default;
#  else
    bool operator==( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window );
#    endif
    }

    bool operator!=( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType                sType  = StructureType::eAndroidSurfaceCreateInfoKHR;
    void const *                 pNext  = {};
    AndroidSurfaceCreateFlagsKHR flags  = {};
    struct ANativeWindow *       window = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAndroidSurfaceCreateInfoKHR>
  {
    using Type = AndroidSurfaceCreateInfoKHR;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eAndroidSurfaceCreateInfoKHR>
  {
    using Type = AndroidSurfaceCreateInfoKHR;
  };
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

  // wrapper struct for struct VkAntiLagPresentationInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagPresentationInfoAMD.html
  struct AntiLagPresentationInfoAMD
  {
    using NativeType = VkAntiLagPresentationInfoAMD;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAntiLagPresentationInfoAMD;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      AntiLagPresentationInfoAMD( AntiLagStageAMD stage_ = AntiLagStageAMD::eInput, uint64_t frameIndex_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , stage{ stage_ }
      , frameIndex{ frameIndex_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AntiLagPresentationInfoAMD( AntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AntiLagPresentationInfoAMD( VkAntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
      : AntiLagPresentationInfoAMD( *reinterpret_cast<AntiLagPresentationInfoAMD const *>( &rhs ) )
    {
    }

    AntiLagPresentationInfoAMD & operator=( AntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AntiLagPresentationInfoAMD & operator=( VkAntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AntiLagPresentationInfoAMD const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD & setStage( AntiLagStageAMD stage_ ) & VULKAN_HPP_NOEXCEPT
    {
      stage = stage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD && setStage( AntiLagStageAMD stage_ ) && VULKAN_HPP_NOEXCEPT
    {
      stage = stage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD & setFrameIndex( uint64_t frameIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      frameIndex = frameIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD && setFrameIndex( uint64_t frameIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      frameIndex = frameIndex_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAntiLagPresentationInfoAMD const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAntiLagPresentationInfoAMD const *>( this );
    }

    operator VkAntiLagPresentationInfoAMD &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAntiLagPresentationInfoAMD *>( this );
    }

    operator VkAntiLagPresentationInfoAMD const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAntiLagPresentationInfoAMD const *>( this );
    }

    operator VkAntiLagPresentationInfoAMD *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAntiLagPresentationInfoAMD *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, AntiLagStageAMD const &, uint64_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, stage, frameIndex );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AntiLagPresentationInfoAMD const & ) const = default;
#else
    bool operator==( AntiLagPresentationInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( frameIndex == rhs.frameIndex );
#  endif
    }

    bool operator!=( AntiLagPresentationInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType   sType      = StructureType::eAntiLagPresentationInfoAMD;
    void *          pNext      = {};
    AntiLagStageAMD stage      = AntiLagStageAMD::eInput;
    uint64_t        frameIndex = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAntiLagPresentationInfoAMD>
  {
    using Type = AntiLagPresentationInfoAMD;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAntiLagPresentationInfoAMD>
  {
    using Type = AntiLagPresentationInfoAMD;
  };

  // wrapper struct for struct VkAntiLagDataAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagDataAMD.html
  struct AntiLagDataAMD
  {
    using NativeType = VkAntiLagDataAMD;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAntiLagDataAMD;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AntiLagDataAMD( AntiLagModeAMD                     mode_              = AntiLagModeAMD::eDriverControl,
                                         uint32_t                           maxFPS_            = {},
                                         AntiLagPresentationInfoAMD const * pPresentationInfo_ = {},
                                         void const *                       pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , mode{ mode_ }
      , maxFPS{ maxFPS_ }
      , pPresentationInfo{ pPresentationInfo_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AntiLagDataAMD( AntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AntiLagDataAMD( VkAntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT : AntiLagDataAMD( *reinterpret_cast<AntiLagDataAMD const *>( &rhs ) ) {}

    AntiLagDataAMD & operator=( AntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AntiLagDataAMD & operator=( VkAntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AntiLagDataAMD const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setMode( AntiLagModeAMD mode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setMode( AntiLagModeAMD mode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setMaxFPS( uint32_t maxFPS_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxFPS = maxFPS_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setMaxFPS( uint32_t maxFPS_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxFPS = maxFPS_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setPPresentationInfo( AntiLagPresentationInfoAMD const * pPresentationInfo_ ) & VULKAN_HPP_NOEXCEPT
    {
      pPresentationInfo = pPresentationInfo_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setPPresentationInfo( AntiLagPresentationInfoAMD const * pPresentationInfo_ ) && VULKAN_HPP_NOEXCEPT
    {
      pPresentationInfo = pPresentationInfo_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAntiLagDataAMD const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAntiLagDataAMD const *>( this );
    }

    operator VkAntiLagDataAMD &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAntiLagDataAMD *>( this );
    }

    operator VkAntiLagDataAMD const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAntiLagDataAMD const *>( this );
    }

    operator VkAntiLagDataAMD *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAntiLagDataAMD *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, AntiLagModeAMD const &, uint32_t const &, AntiLagPresentationInfoAMD const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, mode, maxFPS, pPresentationInfo );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AntiLagDataAMD const & ) const = default;
#else
    bool operator==( AntiLagDataAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( maxFPS == rhs.maxFPS ) &&
             ( pPresentationInfo == rhs.pPresentationInfo );
#  endif
    }

    bool operator!=( AntiLagDataAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                      sType             = StructureType::eAntiLagDataAMD;
    void const *                       pNext             = {};
    AntiLagModeAMD                     mode              = AntiLagModeAMD::eDriverControl;
    uint32_t                           maxFPS            = {};
    AntiLagPresentationInfoAMD const * pPresentationInfo = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAntiLagDataAMD>
  {
    using Type = AntiLagDataAMD;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAntiLagDataAMD>
  {
    using Type = AntiLagDataAMD;
  };

  // wrapper struct for struct VkApplicationInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkApplicationInfo.html
  struct ApplicationInfo
  {
    using NativeType = VkApplicationInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eApplicationInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ApplicationInfo( char const * pApplicationName_   = {},
                                          uint32_t     applicationVersion_ = {},
                                          char const * pEngineName_        = {},
                                          uint32_t     engineVersion_      = {},
                                          uint32_t     apiVersion_         = {},
                                          void const * pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pApplicationName{ pApplicationName_ }
      , applicationVersion{ applicationVersion_ }
      , pEngineName{ pEngineName_ }
      , engineVersion{ engineVersion_ }
      , apiVersion{ apiVersion_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ApplicationInfo( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT : ApplicationInfo( *reinterpret_cast<ApplicationInfo const *>( &rhs ) ) {}

    ApplicationInfo & operator=( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ApplicationInfo & operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ApplicationInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setPApplicationName( char const * pApplicationName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pApplicationName = pApplicationName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setPApplicationName( char const * pApplicationName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pApplicationName = pApplicationName_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setApplicationVersion( uint32_t applicationVersion_ ) & VULKAN_HPP_NOEXCEPT
    {
      applicationVersion = applicationVersion_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setApplicationVersion( uint32_t applicationVersion_ ) && VULKAN_HPP_NOEXCEPT
    {
      applicationVersion = applicationVersion_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setPEngineName( char const * pEngineName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pEngineName = pEngineName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setPEngineName( char const * pEngineName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pEngineName = pEngineName_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setEngineVersion( uint32_t engineVersion_ ) & VULKAN_HPP_NOEXCEPT
    {
      engineVersion = engineVersion_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setEngineVersion( uint32_t engineVersion_ ) && VULKAN_HPP_NOEXCEPT
    {
      engineVersion = engineVersion_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setApiVersion( uint32_t apiVersion_ ) & VULKAN_HPP_NOEXCEPT
    {
      apiVersion = apiVersion_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setApiVersion( uint32_t apiVersion_ ) && VULKAN_HPP_NOEXCEPT
    {
      apiVersion = apiVersion_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkApplicationInfo const *>( this );
    }

    operator VkApplicationInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkApplicationInfo *>( this );
    }

    operator VkApplicationInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkApplicationInfo const *>( this );
    }

    operator VkApplicationInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkApplicationInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, char const * const &, uint32_t const &, char const * const &, uint32_t const &, uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( pApplicationName != rhs.pApplicationName )
        if ( auto cmp = strcmp( pApplicationName, rhs.pApplicationName ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
      if ( auto cmp = applicationVersion <=> rhs.applicationVersion; cmp != 0 )
        return cmp;
      if ( pEngineName != rhs.pEngineName )
        if ( auto cmp = strcmp( pEngineName, rhs.pEngineName ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
      if ( auto cmp = engineVersion <=> rhs.engineVersion; cmp != 0 )
        return cmp;
      if ( auto cmp = apiVersion <=> rhs.apiVersion; cmp != 0 )
        return cmp;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
             ( ( pApplicationName == rhs.pApplicationName ) || ( strcmp( pApplicationName, rhs.pApplicationName ) == 0 ) ) &&
             ( applicationVersion == rhs.applicationVersion ) && ( ( pEngineName == rhs.pEngineName ) || ( strcmp( pEngineName, rhs.pEngineName ) == 0 ) ) &&
             ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion );
    }

    bool operator!=( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType sType              = StructureType::eApplicationInfo;
    void const *  pNext              = {};
    char const *  pApplicationName   = {};
    uint32_t      applicationVersion = {};
    char const *  pEngineName        = {};
    uint32_t      engineVersion      = {};
    uint32_t      apiVersion         = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkApplicationInfo>
  {
    using Type = ApplicationInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eApplicationInfo>
  {
    using Type = ApplicationInfo;
  };

  // wrapper struct for struct VkAttachmentDescription, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescription.html
  struct AttachmentDescription
  {
    using NativeType = VkAttachmentDescription;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AttachmentDescription( AttachmentDescriptionFlags flags_          = {},
                                                Format                     format_         = Format::eUndefined,
                                                SampleCountFlagBits        samples_        = SampleCountFlagBits::e1,
                                                AttachmentLoadOp           loadOp_         = AttachmentLoadOp::eLoad,
                                                AttachmentStoreOp          storeOp_        = AttachmentStoreOp::eStore,
                                                AttachmentLoadOp           stencilLoadOp_  = AttachmentLoadOp::eLoad,
                                                AttachmentStoreOp          stencilStoreOp_ = AttachmentStoreOp::eStore,
                                                ImageLayout                initialLayout_  = ImageLayout::eUndefined,
                                                ImageLayout                finalLayout_    = ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
      : flags{ flags_ }
      , format{ format_ }
      , samples{ samples_ }
      , loadOp{ loadOp_ }
      , storeOp{ storeOp_ }
      , stencilLoadOp{ stencilLoadOp_ }
      , stencilStoreOp{ stencilStoreOp_ }
      , initialLayout{ initialLayout_ }
      , finalLayout{ finalLayout_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AttachmentDescription( AttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AttachmentDescription( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
      : AttachmentDescription( *reinterpret_cast<AttachmentDescription const *>( &rhs ) )
    {
    }

    AttachmentDescription & operator=( AttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AttachmentDescription & operator=( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AttachmentDescription const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setFlags( AttachmentDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setFlags( AttachmentDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT
    {
      samples = samples_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT
    {
      samples = samples_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setLoadOp( AttachmentLoadOp loadOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      loadOp = loadOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setLoadOp( AttachmentLoadOp loadOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      loadOp = loadOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setStoreOp( AttachmentStoreOp storeOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      storeOp = storeOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setStoreOp( AttachmentStoreOp storeOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      storeOp = storeOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencilLoadOp = stencilLoadOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencilLoadOp = stencilLoadOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencilStoreOp = stencilStoreOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencilStoreOp = stencilStoreOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setInitialLayout( ImageLayout initialLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      initialLayout = initialLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setInitialLayout( ImageLayout initialLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      initialLayout = initialLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setFinalLayout( ImageLayout finalLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      finalLayout = finalLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setFinalLayout( ImageLayout finalLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      finalLayout = finalLayout_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentDescription const *>( this );
    }

    operator VkAttachmentDescription &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentDescription *>( this );
    }

    operator VkAttachmentDescription const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentDescription const *>( this );
    }

    operator VkAttachmentDescription *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentDescription *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<AttachmentDescriptionFlags const &,
               Format const &,
               SampleCountFlagBits const &,
               AttachmentLoadOp const &,
               AttachmentStoreOp const &,
               AttachmentLoadOp const &,
               AttachmentStoreOp const &,
               ImageLayout const &,
               ImageLayout const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AttachmentDescription const & ) const = default;
#else
    bool operator==( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) && ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) &&
             ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) && ( initialLayout == rhs.initialLayout ) &&
             ( finalLayout == rhs.finalLayout );
#  endif
    }

    bool operator!=( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    AttachmentDescriptionFlags flags          = {};
    Format                     format         = Format::eUndefined;
    SampleCountFlagBits        samples        = SampleCountFlagBits::e1;
    AttachmentLoadOp           loadOp         = AttachmentLoadOp::eLoad;
    AttachmentStoreOp          storeOp        = AttachmentStoreOp::eStore;
    AttachmentLoadOp           stencilLoadOp  = AttachmentLoadOp::eLoad;
    AttachmentStoreOp          stencilStoreOp = AttachmentStoreOp::eStore;
    ImageLayout                initialLayout  = ImageLayout::eUndefined;
    ImageLayout                finalLayout    = ImageLayout::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAttachmentDescription>
  {
    using Type = AttachmentDescription;
  };
#endif

  // wrapper struct for struct VkAttachmentDescription2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescription2.html
  struct AttachmentDescription2
  {
    using NativeType = VkAttachmentDescription2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAttachmentDescription2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AttachmentDescription2( AttachmentDescriptionFlags flags_          = {},
                                                 Format                     format_         = Format::eUndefined,
                                                 SampleCountFlagBits        samples_        = SampleCountFlagBits::e1,
                                                 AttachmentLoadOp           loadOp_         = AttachmentLoadOp::eLoad,
                                                 AttachmentStoreOp          storeOp_        = AttachmentStoreOp::eStore,
                                                 AttachmentLoadOp           stencilLoadOp_  = AttachmentLoadOp::eLoad,
                                                 AttachmentStoreOp          stencilStoreOp_ = AttachmentStoreOp::eStore,
                                                 ImageLayout                initialLayout_  = ImageLayout::eUndefined,
                                                 ImageLayout                finalLayout_    = ImageLayout::eUndefined,
                                                 void const *               pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , format{ format_ }
      , samples{ samples_ }
      , loadOp{ loadOp_ }
      , storeOp{ storeOp_ }
      , stencilLoadOp{ stencilLoadOp_ }
      , stencilStoreOp{ stencilStoreOp_ }
      , initialLayout{ initialLayout_ }
      , finalLayout{ finalLayout_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AttachmentDescription2( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AttachmentDescription2( VkAttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT
      : AttachmentDescription2( *reinterpret_cast<AttachmentDescription2 const *>( &rhs ) )
    {
    }

    AttachmentDescription2 & operator=( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AttachmentDescription2 & operator=( VkAttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AttachmentDescription2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setFlags( AttachmentDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setFlags( AttachmentDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT
    {
      samples = samples_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT
    {
      samples = samples_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setLoadOp( AttachmentLoadOp loadOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      loadOp = loadOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setLoadOp( AttachmentLoadOp loadOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      loadOp = loadOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setStoreOp( AttachmentStoreOp storeOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      storeOp = storeOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setStoreOp( AttachmentStoreOp storeOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      storeOp = storeOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencilLoadOp = stencilLoadOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencilLoadOp = stencilLoadOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencilStoreOp = stencilStoreOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencilStoreOp = stencilStoreOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setInitialLayout( ImageLayout initialLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      initialLayout = initialLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setInitialLayout( ImageLayout initialLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      initialLayout = initialLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setFinalLayout( ImageLayout finalLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      finalLayout = finalLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setFinalLayout( ImageLayout finalLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      finalLayout = finalLayout_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentDescription2 const *>( this );
    }

    operator VkAttachmentDescription2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentDescription2 *>( this );
    }

    operator VkAttachmentDescription2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentDescription2 const *>( this );
    }

    operator VkAttachmentDescription2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentDescription2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AttachmentDescriptionFlags const &,
               Format const &,
               SampleCountFlagBits const &,
               AttachmentLoadOp const &,
               AttachmentStoreOp const &,
               AttachmentLoadOp const &,
               AttachmentStoreOp const &,
               ImageLayout const &,
               ImageLayout const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AttachmentDescription2 const & ) const = default;
#else
    bool operator==( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) &&
             ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) &&
             ( initialLayout == rhs.initialLayout ) && ( finalLayout == rhs.finalLayout );
#  endif
    }

    bool operator!=( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType              sType          = StructureType::eAttachmentDescription2;
    void const *               pNext          = {};
    AttachmentDescriptionFlags flags          = {};
    Format                     format         = Format::eUndefined;
    SampleCountFlagBits        samples        = SampleCountFlagBits::e1;
    AttachmentLoadOp           loadOp         = AttachmentLoadOp::eLoad;
    AttachmentStoreOp          storeOp        = AttachmentStoreOp::eStore;
    AttachmentLoadOp           stencilLoadOp  = AttachmentLoadOp::eLoad;
    AttachmentStoreOp          stencilStoreOp = AttachmentStoreOp::eStore;
    ImageLayout                initialLayout  = ImageLayout::eUndefined;
    ImageLayout                finalLayout    = ImageLayout::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAttachmentDescription2>
  {
    using Type = AttachmentDescription2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAttachmentDescription2>
  {
    using Type = AttachmentDescription2;
  };

  using AttachmentDescription2KHR = AttachmentDescription2;

  // wrapper struct for struct VkAttachmentDescriptionStencilLayout, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionStencilLayout.html
  struct AttachmentDescriptionStencilLayout
  {
    using NativeType = VkAttachmentDescriptionStencilLayout;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAttachmentDescriptionStencilLayout;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( ImageLayout stencilInitialLayout_ = ImageLayout::eUndefined,
                                                             ImageLayout stencilFinalLayout_   = ImageLayout::eUndefined,
                                                             void *      pNext_                = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , stencilInitialLayout{ stencilInitialLayout_ }
      , stencilFinalLayout{ stencilFinalLayout_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AttachmentDescriptionStencilLayout( VkAttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
      : AttachmentDescriptionStencilLayout( *reinterpret_cast<AttachmentDescriptionStencilLayout const *>( &rhs ) )
    {
    }

    AttachmentDescriptionStencilLayout & operator=( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AttachmentDescriptionStencilLayout & operator=( VkAttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AttachmentDescriptionStencilLayout const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout & setStencilInitialLayout( ImageLayout stencilInitialLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencilInitialLayout = stencilInitialLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout && setStencilInitialLayout( ImageLayout stencilInitialLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencilInitialLayout = stencilInitialLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout & setStencilFinalLayout( ImageLayout stencilFinalLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencilFinalLayout = stencilFinalLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout && setStencilFinalLayout( ImageLayout stencilFinalLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencilFinalLayout = stencilFinalLayout_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentDescriptionStencilLayout const *>( this );
    }

    operator VkAttachmentDescriptionStencilLayout &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentDescriptionStencilLayout *>( this );
    }

    operator VkAttachmentDescriptionStencilLayout const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentDescriptionStencilLayout const *>( this );
    }

    operator VkAttachmentDescriptionStencilLayout *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentDescriptionStencilLayout *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, ImageLayout const &, ImageLayout const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AttachmentDescriptionStencilLayout const & ) const = default;
#else
    bool operator==( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) &&
             ( stencilFinalLayout == rhs.stencilFinalLayout );
#  endif
    }

    bool operator!=( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                = StructureType::eAttachmentDescriptionStencilLayout;
    void *        pNext                = {};
    ImageLayout   stencilInitialLayout = ImageLayout::eUndefined;
    ImageLayout   stencilFinalLayout   = ImageLayout::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAttachmentDescriptionStencilLayout>
  {
    using Type = AttachmentDescriptionStencilLayout;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAttachmentDescriptionStencilLayout>
  {
    using Type = AttachmentDescriptionStencilLayout;
  };

  using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;

  // wrapper struct for struct VkAttachmentFeedbackLoopInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentFeedbackLoopInfoEXT.html
  struct AttachmentFeedbackLoopInfoEXT
  {
    using NativeType = VkAttachmentFeedbackLoopInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAttachmentFeedbackLoopInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AttachmentFeedbackLoopInfoEXT( Bool32 feedbackLoopEnable_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , feedbackLoopEnable{ feedbackLoopEnable_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AttachmentFeedbackLoopInfoEXT( AttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AttachmentFeedbackLoopInfoEXT( VkAttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : AttachmentFeedbackLoopInfoEXT( *reinterpret_cast<AttachmentFeedbackLoopInfoEXT const *>( &rhs ) )
    {
    }

    AttachmentFeedbackLoopInfoEXT & operator=( AttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AttachmentFeedbackLoopInfoEXT & operator=( VkAttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AttachmentFeedbackLoopInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT & setFeedbackLoopEnable( Bool32 feedbackLoopEnable_ ) & VULKAN_HPP_NOEXCEPT
    {
      feedbackLoopEnable = feedbackLoopEnable_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT && setFeedbackLoopEnable( Bool32 feedbackLoopEnable_ ) && VULKAN_HPP_NOEXCEPT
    {
      feedbackLoopEnable = feedbackLoopEnable_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAttachmentFeedbackLoopInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentFeedbackLoopInfoEXT const *>( this );
    }

    operator VkAttachmentFeedbackLoopInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentFeedbackLoopInfoEXT *>( this );
    }

    operator VkAttachmentFeedbackLoopInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentFeedbackLoopInfoEXT const *>( this );
    }

    operator VkAttachmentFeedbackLoopInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentFeedbackLoopInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, feedbackLoopEnable );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AttachmentFeedbackLoopInfoEXT const & ) const = default;
#else
    bool operator==( AttachmentFeedbackLoopInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( feedbackLoopEnable == rhs.feedbackLoopEnable );
#  endif
    }

    bool operator!=( AttachmentFeedbackLoopInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType              = StructureType::eAttachmentFeedbackLoopInfoEXT;
    void const *  pNext              = {};
    Bool32        feedbackLoopEnable = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAttachmentFeedbackLoopInfoEXT>
  {
    using Type = AttachmentFeedbackLoopInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAttachmentFeedbackLoopInfoEXT>
  {
    using Type = AttachmentFeedbackLoopInfoEXT;
  };

  // wrapper struct for struct VkAttachmentReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReference.html
  struct AttachmentReference
  {
    using NativeType = VkAttachmentReference;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AttachmentReference( uint32_t attachment_ = {}, ImageLayout layout_ = ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
      : attachment{ attachment_ }
      , layout{ layout_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AttachmentReference( AttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AttachmentReference( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT : AttachmentReference( *reinterpret_cast<AttachmentReference const *>( &rhs ) )
    {
    }

    AttachmentReference & operator=( AttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AttachmentReference & operator=( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AttachmentReference const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AttachmentReference & setAttachment( uint32_t attachment_ ) & VULKAN_HPP_NOEXCEPT
    {
      attachment = attachment_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference && setAttachment( uint32_t attachment_ ) && VULKAN_HPP_NOEXCEPT
    {
      attachment = attachment_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentReference const *>( this );
    }

    operator VkAttachmentReference &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentReference *>( this );
    }

    operator VkAttachmentReference const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentReference const *>( this );
    }

    operator VkAttachmentReference *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentReference *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, ImageLayout const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( attachment, layout );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AttachmentReference const & ) const = default;
#else
    bool operator==( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( attachment == rhs.attachment ) && ( layout == rhs.layout );
#  endif
    }

    bool operator!=( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t    attachment = {};
    ImageLayout layout     = ImageLayout::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAttachmentReference>
  {
    using Type = AttachmentReference;
  };
#endif

  // wrapper struct for struct VkAttachmentReference2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReference2.html
  struct AttachmentReference2
  {
    using NativeType = VkAttachmentReference2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAttachmentReference2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AttachmentReference2( uint32_t         attachment_ = {},
                                               ImageLayout      layout_     = ImageLayout::eUndefined,
                                               ImageAspectFlags aspectMask_ = {},
                                               void const *     pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , attachment{ attachment_ }
      , layout{ layout_ }
      , aspectMask{ aspectMask_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AttachmentReference2( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AttachmentReference2( VkAttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT
      : AttachmentReference2( *reinterpret_cast<AttachmentReference2 const *>( &rhs ) )
    {
    }

    AttachmentReference2 & operator=( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AttachmentReference2 & operator=( VkAttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AttachmentReference2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setAttachment( uint32_t attachment_ ) & VULKAN_HPP_NOEXCEPT
    {
      attachment = attachment_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setAttachment( uint32_t attachment_ ) && VULKAN_HPP_NOEXCEPT
    {
      attachment = attachment_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentReference2 const *>( this );
    }

    operator VkAttachmentReference2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentReference2 *>( this );
    }

    operator VkAttachmentReference2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentReference2 const *>( this );
    }

    operator VkAttachmentReference2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentReference2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, ImageLayout const &, ImageAspectFlags const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, attachment, layout, aspectMask );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AttachmentReference2 const & ) const = default;
#else
    bool operator==( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) && ( layout == rhs.layout ) &&
             ( aspectMask == rhs.aspectMask );
#  endif
    }

    bool operator!=( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType      = StructureType::eAttachmentReference2;
    void const *     pNext      = {};
    uint32_t         attachment = {};
    ImageLayout      layout     = ImageLayout::eUndefined;
    ImageAspectFlags aspectMask = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAttachmentReference2>
  {
    using Type = AttachmentReference2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAttachmentReference2>
  {
    using Type = AttachmentReference2;
  };

  using AttachmentReference2KHR = AttachmentReference2;

  // wrapper struct for struct VkAttachmentReferenceStencilLayout, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReferenceStencilLayout.html
  struct AttachmentReferenceStencilLayout
  {
    using NativeType = VkAttachmentReferenceStencilLayout;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAttachmentReferenceStencilLayout;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( ImageLayout stencilLayout_ = ImageLayout::eUndefined, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , stencilLayout{ stencilLayout_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AttachmentReferenceStencilLayout( VkAttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
      : AttachmentReferenceStencilLayout( *reinterpret_cast<AttachmentReferenceStencilLayout const *>( &rhs ) )
    {
    }

    AttachmentReferenceStencilLayout & operator=( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AttachmentReferenceStencilLayout & operator=( VkAttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AttachmentReferenceStencilLayout const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout & setStencilLayout( ImageLayout stencilLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencilLayout = stencilLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout && setStencilLayout( ImageLayout stencilLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencilLayout = stencilLayout_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentReferenceStencilLayout const *>( this );
    }

    operator VkAttachmentReferenceStencilLayout &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentReferenceStencilLayout *>( this );
    }

    operator VkAttachmentReferenceStencilLayout const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentReferenceStencilLayout const *>( this );
    }

    operator VkAttachmentReferenceStencilLayout *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentReferenceStencilLayout *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, ImageLayout const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, stencilLayout );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AttachmentReferenceStencilLayout const & ) const = default;
#else
    bool operator==( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout );
#  endif
    }

    bool operator!=( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType         = StructureType::eAttachmentReferenceStencilLayout;
    void *        pNext         = {};
    ImageLayout   stencilLayout = ImageLayout::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAttachmentReferenceStencilLayout>
  {
    using Type = AttachmentReferenceStencilLayout;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAttachmentReferenceStencilLayout>
  {
    using Type = AttachmentReferenceStencilLayout;
  };

  using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;

  // wrapper struct for struct VkAttachmentSampleCountInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentSampleCountInfoAMD.html
  struct AttachmentSampleCountInfoAMD
  {
    using NativeType = VkAttachmentSampleCountInfoAMD;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eAttachmentSampleCountInfoAMD;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AttachmentSampleCountInfoAMD( uint32_t                    colorAttachmentCount_          = {},
                                                       SampleCountFlagBits const * pColorAttachmentSamples_       = {},
                                                       SampleCountFlagBits         depthStencilAttachmentSamples_ = SampleCountFlagBits::e1,
                                                       void const *                pNext_                         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , colorAttachmentCount{ colorAttachmentCount_ }
      , pColorAttachmentSamples{ pColorAttachmentSamples_ }
      , depthStencilAttachmentSamples{ depthStencilAttachmentSamples_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AttachmentSampleCountInfoAMD( AttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AttachmentSampleCountInfoAMD( VkAttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
      : AttachmentSampleCountInfoAMD( *reinterpret_cast<AttachmentSampleCountInfoAMD const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AttachmentSampleCountInfoAMD( ArrayProxyNoTemporaries<SampleCountFlagBits const> const & colorAttachmentSamples_,
                                  SampleCountFlagBits                                        depthStencilAttachmentSamples_ = SampleCountFlagBits::e1,
                                  void const *                                               pNext_                         = nullptr )
      : pNext( pNext_ )
      , colorAttachmentCount( static_cast<uint32_t>( colorAttachmentSamples_.size() ) )
      , pColorAttachmentSamples( colorAttachmentSamples_.data() )
      , depthStencilAttachmentSamples( depthStencilAttachmentSamples_ )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    AttachmentSampleCountInfoAMD & operator=( AttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AttachmentSampleCountInfoAMD & operator=( VkAttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AttachmentSampleCountInfoAMD const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      colorAttachmentCount = colorAttachmentCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      colorAttachmentCount = colorAttachmentCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setPColorAttachmentSamples( SampleCountFlagBits const * pColorAttachmentSamples_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pColorAttachmentSamples = pColorAttachmentSamples_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setPColorAttachmentSamples( SampleCountFlagBits const * pColorAttachmentSamples_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pColorAttachmentSamples = pColorAttachmentSamples_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    AttachmentSampleCountInfoAMD &
      setColorAttachmentSamples( ArrayProxyNoTemporaries<SampleCountFlagBits const> const & colorAttachmentSamples_ ) VULKAN_HPP_NOEXCEPT
    {
      colorAttachmentCount    = static_cast<uint32_t>( colorAttachmentSamples_.size() );
      pColorAttachmentSamples = colorAttachmentSamples_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setDepthStencilAttachmentSamples( SampleCountFlagBits depthStencilAttachmentSamples_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      depthStencilAttachmentSamples = depthStencilAttachmentSamples_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setDepthStencilAttachmentSamples( SampleCountFlagBits depthStencilAttachmentSamples_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      depthStencilAttachmentSamples = depthStencilAttachmentSamples_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAttachmentSampleCountInfoAMD const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentSampleCountInfoAMD const *>( this );
    }

    operator VkAttachmentSampleCountInfoAMD &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentSampleCountInfoAMD *>( this );
    }

    operator VkAttachmentSampleCountInfoAMD const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentSampleCountInfoAMD const *>( this );
    }

    operator VkAttachmentSampleCountInfoAMD *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentSampleCountInfoAMD *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, SampleCountFlagBits const * const &, SampleCountFlagBits const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AttachmentSampleCountInfoAMD const & ) const = default;
#else
    bool operator==( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
             ( pColorAttachmentSamples == rhs.pColorAttachmentSamples ) && ( depthStencilAttachmentSamples == rhs.depthStencilAttachmentSamples );
#  endif
    }

    bool operator!=( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType               sType                         = StructureType::eAttachmentSampleCountInfoAMD;
    void const *                pNext                         = {};
    uint32_t                    colorAttachmentCount          = {};
    SampleCountFlagBits const * pColorAttachmentSamples       = {};
    SampleCountFlagBits         depthStencilAttachmentSamples = SampleCountFlagBits::e1;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAttachmentSampleCountInfoAMD>
  {
    using Type = AttachmentSampleCountInfoAMD;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eAttachmentSampleCountInfoAMD>
  {
    using Type = AttachmentSampleCountInfoAMD;
  };

  using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;

  // wrapper struct for struct VkExtent2D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExtent2D.html
  struct Extent2D
  {
    using NativeType = VkExtent2D;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR Extent2D( uint32_t width_ = {}, uint32_t height_ = {} ) VULKAN_HPP_NOEXCEPT
      : width{ width_ }
      , height{ height_ }
    {
    }

    VULKAN_HPP_CONSTEXPR Extent2D( Extent2D const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    Extent2D( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT : Extent2D( *reinterpret_cast<Extent2D const *>( &rhs ) ) {}

    Extent2D & operator=( Extent2D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    Extent2D & operator=( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<Extent2D const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 Extent2D & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT
    {
      width = width_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Extent2D && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT
    {
      width = width_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Extent2D & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT
    {
      height = height_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Extent2D && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT
    {
      height = height_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkExtent2D const *>( this );
    }

    operator VkExtent2D &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkExtent2D *>( this );
    }

    operator VkExtent2D const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkExtent2D const *>( this );
    }

    operator VkExtent2D *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkExtent2D *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( width, height );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( Extent2D const & ) const = default;
#else
    bool operator==( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( width == rhs.width ) && ( height == rhs.height );
#  endif
    }

    bool operator!=( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t width  = {};
    uint32_t height = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkExtent2D>
  {
    using Type = Extent2D;
  };
#endif

  // wrapper struct for struct VkSampleLocationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleLocationEXT.html
  struct SampleLocationEXT
  {
    using NativeType = VkSampleLocationEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SampleLocationEXT( float x_ = {}, float y_ = {} ) VULKAN_HPP_NOEXCEPT
      : x{ x_ }
      , y{ y_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SampleLocationEXT( SampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SampleLocationEXT( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT : SampleLocationEXT( *reinterpret_cast<SampleLocationEXT const *>( &rhs ) ) {}

    SampleLocationEXT & operator=( SampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SampleLocationEXT & operator=( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SampleLocationEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT & setX( float x_ ) & VULKAN_HPP_NOEXCEPT
    {
      x = x_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT && setX( float x_ ) && VULKAN_HPP_NOEXCEPT
    {
      x = x_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT & setY( float y_ ) & VULKAN_HPP_NOEXCEPT
    {
      y = y_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT && setY( float y_ ) && VULKAN_HPP_NOEXCEPT
    {
      y = y_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSampleLocationEXT const *>( this );
    }

    operator VkSampleLocationEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSampleLocationEXT *>( this );
    }

    operator VkSampleLocationEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSampleLocationEXT const *>( this );
    }

    operator VkSampleLocationEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSampleLocationEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<float const &, float const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( x, y );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SampleLocationEXT const & ) const = default;
#else
    bool operator==( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( x == rhs.x ) && ( y == rhs.y );
#  endif
    }

    bool operator!=( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    float x = {};
    float y = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSampleLocationEXT>
  {
    using Type = SampleLocationEXT;
  };
#endif

  // wrapper struct for struct VkSampleLocationsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleLocationsInfoEXT.html
  struct SampleLocationsInfoEXT
  {
    using NativeType = VkSampleLocationsInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eSampleLocationsInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( SampleCountFlagBits       sampleLocationsPerPixel_ = SampleCountFlagBits::e1,
                                                 Extent2D                  sampleLocationGridSize_  = {},
                                                 uint32_t                  sampleLocationsCount_    = {},
                                                 SampleLocationEXT const * pSampleLocations_        = {},
                                                 void const *              pNext_                   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , sampleLocationsPerPixel{ sampleLocationsPerPixel_ }
      , sampleLocationGridSize{ sampleLocationGridSize_ }
      , sampleLocationsCount{ sampleLocationsCount_ }
      , pSampleLocations{ pSampleLocations_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : SampleLocationsInfoEXT( *reinterpret_cast<SampleLocationsInfoEXT const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    SampleLocationsInfoEXT( SampleCountFlagBits                                      sampleLocationsPerPixel_,
                            Extent2D                                                 sampleLocationGridSize_,
                            ArrayProxyNoTemporaries<SampleLocationEXT const> const & sampleLocations_,
                            void const *                                             pNext_ = nullptr )
      : pNext( pNext_ )
      , sampleLocationsPerPixel( sampleLocationsPerPixel_ )
      , sampleLocationGridSize( sampleLocationGridSize_ )
      , sampleLocationsCount( static_cast<uint32_t>( sampleLocations_.size() ) )
      , pSampleLocations( sampleLocations_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    SampleLocationsInfoEXT & operator=( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SampleLocationsInfoEXT & operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SampleLocationsInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ ) & VULKAN_HPP_NOEXCEPT
    {
      sampleLocationsPerPixel = sampleLocationsPerPixel_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ ) && VULKAN_HPP_NOEXCEPT
    {
      sampleLocationsPerPixel = sampleLocationsPerPixel_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setSampleLocationGridSize( Extent2D const & sampleLocationGridSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      sampleLocationGridSize = sampleLocationGridSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setSampleLocationGridSize( Extent2D const & sampleLocationGridSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      sampleLocationGridSize = sampleLocationGridSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setSampleLocationsCount( uint32_t sampleLocationsCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      sampleLocationsCount = sampleLocationsCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setSampleLocationsCount( uint32_t sampleLocationsCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      sampleLocationsCount = sampleLocationsCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setPSampleLocations( SampleLocationEXT const * pSampleLocations_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSampleLocations = pSampleLocations_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setPSampleLocations( SampleLocationEXT const * pSampleLocations_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSampleLocations = pSampleLocations_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    SampleLocationsInfoEXT & setSampleLocations( ArrayProxyNoTemporaries<SampleLocationEXT const> const & sampleLocations_ ) VULKAN_HPP_NOEXCEPT
    {
      sampleLocationsCount = static_cast<uint32_t>( sampleLocations_.size() );
      pSampleLocations     = sampleLocations_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSampleLocationsInfoEXT const *>( this );
    }

    operator VkSampleLocationsInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSampleLocationsInfoEXT *>( this );
    }

    operator VkSampleLocationsInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSampleLocationsInfoEXT const *>( this );
    }

    operator VkSampleLocationsInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSampleLocationsInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, SampleCountFlagBits const &, Extent2D const &, uint32_t const &, SampleLocationEXT const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SampleLocationsInfoEXT const & ) const = default;
#else
    bool operator==( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) &&
             ( sampleLocationGridSize == rhs.sampleLocationGridSize ) && ( sampleLocationsCount == rhs.sampleLocationsCount ) &&
             ( pSampleLocations == rhs.pSampleLocations );
#  endif
    }

    bool operator!=( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType             sType                   = StructureType::eSampleLocationsInfoEXT;
    void const *              pNext                   = {};
    SampleCountFlagBits       sampleLocationsPerPixel = SampleCountFlagBits::e1;
    Extent2D                  sampleLocationGridSize  = {};
    uint32_t                  sampleLocationsCount    = {};
    SampleLocationEXT const * pSampleLocations        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSampleLocationsInfoEXT>
  {
    using Type = SampleLocationsInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eSampleLocationsInfoEXT>
  {
    using Type = SampleLocationsInfoEXT;
  };

  // wrapper struct for struct VkAttachmentSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentSampleLocationsEXT.html
  struct AttachmentSampleLocationsEXT
  {
    using NativeType = VkAttachmentSampleLocationsEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = {}, SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT
      : attachmentIndex{ attachmentIndex_ }
      , sampleLocationsInfo{ sampleLocationsInfo_ }
    {
    }

    VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( AttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : AttachmentSampleLocationsEXT( *reinterpret_cast<AttachmentSampleLocationsEXT const *>( &rhs ) )
    {
    }

    AttachmentSampleLocationsEXT & operator=( AttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    AttachmentSampleLocationsEXT & operator=( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<AttachmentSampleLocationsEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT & setAttachmentIndex( uint32_t attachmentIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      attachmentIndex = attachmentIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT && setAttachmentIndex( uint32_t attachmentIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      attachmentIndex = attachmentIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) & VULKAN_HPP_NOEXCEPT
    {
      sampleLocationsInfo = sampleLocationsInfo_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT && setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) && VULKAN_HPP_NOEXCEPT
    {
      sampleLocationsInfo = sampleLocationsInfo_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentSampleLocationsEXT const *>( this );
    }

    operator VkAttachmentSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkAttachmentSampleLocationsEXT *>( this );
    }

    operator VkAttachmentSampleLocationsEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentSampleLocationsEXT const *>( this );
    }

    operator VkAttachmentSampleLocationsEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkAttachmentSampleLocationsEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, SampleLocationsInfoEXT const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( attachmentIndex, sampleLocationsInfo );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( AttachmentSampleLocationsEXT const & ) const = default;
#else
    bool operator==( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( attachmentIndex == rhs.attachmentIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
#  endif
    }

    bool operator!=( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t               attachmentIndex     = {};
    SampleLocationsInfoEXT sampleLocationsInfo = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkAttachmentSampleLocationsEXT>
  {
    using Type = AttachmentSampleLocationsEXT;
  };
#endif

  // wrapper struct for struct VkBaseInStructure, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBaseInStructure.html
  struct BaseInStructure
  {
    using NativeType = VkBaseInStructure;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    BaseInStructure( StructureType sType_ = StructureType::eApplicationInfo, struct BaseInStructure const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : sType{ sType_ }
      , pNext{ pNext_ }
    {
    }

    BaseInStructure( BaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT : BaseInStructure( *reinterpret_cast<BaseInStructure const *>( &rhs ) ) {}

    BaseInStructure & operator=( BaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BaseInStructure & operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BaseInStructure const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BaseInStructure & setPNext( struct BaseInStructure const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BaseInStructure && setPNext( struct BaseInStructure const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBaseInStructure const *>( this );
    }

    operator VkBaseInStructure &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBaseInStructure *>( this );
    }

    operator VkBaseInStructure const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBaseInStructure const *>( this );
    }

    operator VkBaseInStructure *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBaseInStructure *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, struct BaseInStructure const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BaseInStructure const & ) const = default;
#else
    bool operator==( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
#  endif
    }

    bool operator!=( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                  sType = StructureType::eApplicationInfo;
    struct BaseInStructure const * pNext = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBaseInStructure>
  {
    using Type = BaseInStructure;
  };
#endif

  // wrapper struct for struct VkBaseOutStructure, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBaseOutStructure.html
  struct BaseOutStructure
  {
    using NativeType = VkBaseOutStructure;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    BaseOutStructure( StructureType sType_ = StructureType::eApplicationInfo, struct BaseOutStructure * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : sType{ sType_ }
      , pNext{ pNext_ }
    {
    }

    BaseOutStructure( BaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT : BaseOutStructure( *reinterpret_cast<BaseOutStructure const *>( &rhs ) ) {}

    BaseOutStructure & operator=( BaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BaseOutStructure & operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BaseOutStructure const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BaseOutStructure & setPNext( struct BaseOutStructure * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BaseOutStructure && setPNext( struct BaseOutStructure * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBaseOutStructure const *>( this );
    }

    operator VkBaseOutStructure &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBaseOutStructure *>( this );
    }

    operator VkBaseOutStructure const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBaseOutStructure const *>( this );
    }

    operator VkBaseOutStructure *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBaseOutStructure *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, struct BaseOutStructure * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BaseOutStructure const & ) const = default;
#else
    bool operator==( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
#  endif
    }

    bool operator!=( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType             sType = StructureType::eApplicationInfo;
    struct BaseOutStructure * pNext = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBaseOutStructure>
  {
    using Type = BaseOutStructure;
  };
#endif

  // wrapper struct for struct VkBeginCustomResolveInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBeginCustomResolveInfoEXT.html
  struct BeginCustomResolveInfoEXT
  {
    using NativeType = VkBeginCustomResolveInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBeginCustomResolveInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BeginCustomResolveInfoEXT( void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {}

    VULKAN_HPP_CONSTEXPR BeginCustomResolveInfoEXT( BeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BeginCustomResolveInfoEXT( VkBeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : BeginCustomResolveInfoEXT( *reinterpret_cast<BeginCustomResolveInfoEXT const *>( &rhs ) )
    {
    }

    BeginCustomResolveInfoEXT & operator=( BeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BeginCustomResolveInfoEXT & operator=( VkBeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BeginCustomResolveInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BeginCustomResolveInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BeginCustomResolveInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBeginCustomResolveInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBeginCustomResolveInfoEXT const *>( this );
    }

    operator VkBeginCustomResolveInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBeginCustomResolveInfoEXT *>( this );
    }

    operator VkBeginCustomResolveInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBeginCustomResolveInfoEXT const *>( this );
    }

    operator VkBeginCustomResolveInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBeginCustomResolveInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BeginCustomResolveInfoEXT const & ) const = default;
#else
    bool operator==( BeginCustomResolveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
#  endif
    }

    bool operator!=( BeginCustomResolveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType = StructureType::eBeginCustomResolveInfoEXT;
    void *        pNext = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBeginCustomResolveInfoEXT>
  {
    using Type = BeginCustomResolveInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBeginCustomResolveInfoEXT>
  {
    using Type = BeginCustomResolveInfoEXT;
  };

  // wrapper struct for struct VkBindAccelerationStructureMemoryInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindAccelerationStructureMemoryInfoNV.html
  struct BindAccelerationStructureMemoryInfoNV
  {
    using NativeType = VkBindAccelerationStructureMemoryInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindAccelerationStructureMemoryInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = {},
                                                                DeviceMemory            memory_                = {},
                                                                DeviceSize              memoryOffset_          = {},
                                                                uint32_t                deviceIndexCount_      = {},
                                                                uint32_t const *        pDeviceIndices_        = {},
                                                                void const *            pNext_                 = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , accelerationStructure{ accelerationStructure_ }
      , memory{ memory_ }
      , memoryOffset{ memoryOffset_ }
      , deviceIndexCount{ deviceIndexCount_ }
      , pDeviceIndices{ pDeviceIndices_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( BindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindAccelerationStructureMemoryInfoNV( *reinterpret_cast<BindAccelerationStructureMemoryInfoNV const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV                         accelerationStructure_,
                                           DeviceMemory                                    memory_,
                                           DeviceSize                                      memoryOffset_,
                                           ArrayProxyNoTemporaries<uint32_t const> const & deviceIndices_,
                                           void const *                                    pNext_ = nullptr )
      : pNext( pNext_ )
      , accelerationStructure( accelerationStructure_ )
      , memory( memory_ )
      , memoryOffset( memoryOffset_ )
      , deviceIndexCount( static_cast<uint32_t>( deviceIndices_.size() ) )
      , pDeviceIndices( deviceIndices_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    BindAccelerationStructureMemoryInfoNV & operator=( BindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindAccelerationStructureMemoryInfoNV & operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindAccelerationStructureMemoryInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setDeviceIndexCount( uint32_t deviceIndexCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceIndexCount = deviceIndexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setDeviceIndexCount( uint32_t deviceIndexCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceIndexCount = deviceIndexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setPDeviceIndices( uint32_t const * pDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT
    {
      pDeviceIndices = pDeviceIndices_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setPDeviceIndices( uint32_t const * pDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT
    {
      pDeviceIndices = pDeviceIndices_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindAccelerationStructureMemoryInfoNV & setDeviceIndices( ArrayProxyNoTemporaries<uint32_t const> const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT
    {
      deviceIndexCount = static_cast<uint32_t>( deviceIndices_.size() );
      pDeviceIndices   = deviceIndices_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV const *>( this );
    }

    operator VkBindAccelerationStructureMemoryInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV *>( this );
    }

    operator VkBindAccelerationStructureMemoryInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV const *>( this );
    }

    operator VkBindAccelerationStructureMemoryInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AccelerationStructureNV const &,
               DeviceMemory const &,
               DeviceSize const &,
               uint32_t const &,
               uint32_t const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindAccelerationStructureMemoryInfoNV const & ) const = default;
#else
    bool operator==( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) &&
             ( memoryOffset == rhs.memoryOffset ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices );
#  endif
    }

    bool operator!=( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType           sType                 = StructureType::eBindAccelerationStructureMemoryInfoNV;
    void const *            pNext                 = {};
    AccelerationStructureNV accelerationStructure = {};
    DeviceMemory            memory                = {};
    DeviceSize              memoryOffset          = {};
    uint32_t                deviceIndexCount      = {};
    uint32_t const *        pDeviceIndices        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindAccelerationStructureMemoryInfoNV>
  {
    using Type = BindAccelerationStructureMemoryInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindAccelerationStructureMemoryInfoNV>
  {
    using Type = BindAccelerationStructureMemoryInfoNV;
  };

  // wrapper struct for struct VkBindBufferMemoryDeviceGroupInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindBufferMemoryDeviceGroupInfo.html
  struct BindBufferMemoryDeviceGroupInfo
  {
    using NativeType = VkBindBufferMemoryDeviceGroupInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindBufferMemoryDeviceGroupInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t         deviceIndexCount_ = {},
                                                          uint32_t const * pDeviceIndices_   = {},
                                                          void const *     pNext_            = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , deviceIndexCount{ deviceIndexCount_ }
      , pDeviceIndices{ pDeviceIndices_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindBufferMemoryDeviceGroupInfo( *reinterpret_cast<BindBufferMemoryDeviceGroupInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindBufferMemoryDeviceGroupInfo( ArrayProxyNoTemporaries<uint32_t const> const & deviceIndices_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), deviceIndexCount( static_cast<uint32_t>( deviceIndices_.size() ) ), pDeviceIndices( deviceIndices_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    BindBufferMemoryDeviceGroupInfo & operator=( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindBufferMemoryDeviceGroupInfo & operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindBufferMemoryDeviceGroupInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo & setDeviceIndexCount( uint32_t deviceIndexCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceIndexCount = deviceIndexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo && setDeviceIndexCount( uint32_t deviceIndexCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceIndexCount = deviceIndexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo & setPDeviceIndices( uint32_t const * pDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT
    {
      pDeviceIndices = pDeviceIndices_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo && setPDeviceIndices( uint32_t const * pDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT
    {
      pDeviceIndices = pDeviceIndices_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindBufferMemoryDeviceGroupInfo & setDeviceIndices( ArrayProxyNoTemporaries<uint32_t const> const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT
    {
      deviceIndexCount = static_cast<uint32_t>( deviceIndices_.size() );
      pDeviceIndices   = deviceIndices_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo const *>( this );
    }

    operator VkBindBufferMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo *>( this );
    }

    operator VkBindBufferMemoryDeviceGroupInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo const *>( this );
    }

    operator VkBindBufferMemoryDeviceGroupInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, uint32_t const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindBufferMemoryDeviceGroupInfo const & ) const = default;
#else
    bool operator==( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices );
#  endif
    }

    bool operator!=( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType            = StructureType::eBindBufferMemoryDeviceGroupInfo;
    void const *     pNext            = {};
    uint32_t         deviceIndexCount = {};
    uint32_t const * pDeviceIndices   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindBufferMemoryDeviceGroupInfo>
  {
    using Type = BindBufferMemoryDeviceGroupInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindBufferMemoryDeviceGroupInfo>
  {
    using Type = BindBufferMemoryDeviceGroupInfo;
  };

  using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;

  // wrapper struct for struct VkBindBufferMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindBufferMemoryInfo.html
  struct BindBufferMemoryInfo
  {
    using NativeType = VkBindBufferMemoryInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindBufferMemoryInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      BindBufferMemoryInfo( Buffer buffer_ = {}, DeviceMemory memory_ = {}, DeviceSize memoryOffset_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , buffer{ buffer_ }
      , memory{ memory_ }
      , memoryOffset{ memoryOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindBufferMemoryInfo( *reinterpret_cast<BindBufferMemoryInfo const *>( &rhs ) )
    {
    }

    BindBufferMemoryInfo & operator=( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindBufferMemoryInfo & operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindBufferMemoryInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindBufferMemoryInfo const *>( this );
    }

    operator VkBindBufferMemoryInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindBufferMemoryInfo *>( this );
    }

    operator VkBindBufferMemoryInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindBufferMemoryInfo const *>( this );
    }

    operator VkBindBufferMemoryInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindBufferMemoryInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Buffer const &, DeviceMemory const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, buffer, memory, memoryOffset );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindBufferMemoryInfo const & ) const = default;
#else
    bool operator==( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset );
#  endif
    }

    bool operator!=( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType        = StructureType::eBindBufferMemoryInfo;
    void const *  pNext        = {};
    Buffer        buffer       = {};
    DeviceMemory  memory       = {};
    DeviceSize    memoryOffset = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindBufferMemoryInfo>
  {
    using Type = BindBufferMemoryInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindBufferMemoryInfo>
  {
    using Type = BindBufferMemoryInfo;
  };

  using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;

  // wrapper struct for struct VkBindDataGraphPipelineSessionMemoryInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindDataGraphPipelineSessionMemoryInfoARM.html
  struct BindDataGraphPipelineSessionMemoryInfoARM
  {
    using NativeType = VkBindDataGraphPipelineSessionMemoryInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindDataGraphPipelineSessionMemoryInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      BindDataGraphPipelineSessionMemoryInfoARM( DataGraphPipelineSessionARM          session_      = {},
                                                 DataGraphPipelineSessionBindPointARM bindPoint_    = DataGraphPipelineSessionBindPointARM::eTransient,
                                                 uint32_t                             objectIndex_  = {},
                                                 DeviceMemory                         memory_       = {},
                                                 DeviceSize                           memoryOffset_ = {},
                                                 void const *                         pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , session{ session_ }
      , bindPoint{ bindPoint_ }
      , objectIndex{ objectIndex_ }
      , memory{ memory_ }
      , memoryOffset{ memoryOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindDataGraphPipelineSessionMemoryInfoARM( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindDataGraphPipelineSessionMemoryInfoARM( VkBindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindDataGraphPipelineSessionMemoryInfoARM( *reinterpret_cast<BindDataGraphPipelineSessionMemoryInfoARM const *>( &rhs ) )
    {
    }

    BindDataGraphPipelineSessionMemoryInfoARM & operator=( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindDataGraphPipelineSessionMemoryInfoARM & operator=( VkBindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindDataGraphPipelineSessionMemoryInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setSession( DataGraphPipelineSessionARM session_ ) & VULKAN_HPP_NOEXCEPT
    {
      session = session_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setSession( DataGraphPipelineSessionARM session_ ) && VULKAN_HPP_NOEXCEPT
    {
      session = session_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) & VULKAN_HPP_NOEXCEPT
    {
      bindPoint = bindPoint_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) && VULKAN_HPP_NOEXCEPT
    {
      bindPoint = bindPoint_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setObjectIndex( uint32_t objectIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      objectIndex = objectIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setObjectIndex( uint32_t objectIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      objectIndex = objectIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindDataGraphPipelineSessionMemoryInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindDataGraphPipelineSessionMemoryInfoARM const *>( this );
    }

    operator VkBindDataGraphPipelineSessionMemoryInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindDataGraphPipelineSessionMemoryInfoARM *>( this );
    }

    operator VkBindDataGraphPipelineSessionMemoryInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindDataGraphPipelineSessionMemoryInfoARM const *>( this );
    }

    operator VkBindDataGraphPipelineSessionMemoryInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindDataGraphPipelineSessionMemoryInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DataGraphPipelineSessionARM const &,
               DataGraphPipelineSessionBindPointARM const &,
               uint32_t const &,
               DeviceMemory const &,
               DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, session, bindPoint, objectIndex, memory, memoryOffset );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindDataGraphPipelineSessionMemoryInfoARM const & ) const = default;
#else
    bool operator==( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( session == rhs.session ) && ( bindPoint == rhs.bindPoint ) &&
             ( objectIndex == rhs.objectIndex ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset );
#  endif
    }

    bool operator!=( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                        sType        = StructureType::eBindDataGraphPipelineSessionMemoryInfoARM;
    void const *                         pNext        = {};
    DataGraphPipelineSessionARM          session      = {};
    DataGraphPipelineSessionBindPointARM bindPoint    = DataGraphPipelineSessionBindPointARM::eTransient;
    uint32_t                             objectIndex  = {};
    DeviceMemory                         memory       = {};
    DeviceSize                           memoryOffset = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindDataGraphPipelineSessionMemoryInfoARM>
  {
    using Type = BindDataGraphPipelineSessionMemoryInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindDataGraphPipelineSessionMemoryInfoARM>
  {
    using Type = BindDataGraphPipelineSessionMemoryInfoARM;
  };

  // wrapper struct for struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindDescriptorBufferEmbeddedSamplersInfoEXT.html
  struct BindDescriptorBufferEmbeddedSamplersInfoEXT
  {
    using NativeType = VkBindDescriptorBufferEmbeddedSamplersInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindDescriptorBufferEmbeddedSamplersInfoEXT( ShaderStageFlags stageFlags_ = {},
                                                                      PipelineLayout   layout_     = {},
                                                                      uint32_t         set_        = {},
                                                                      void const *     pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , stageFlags{ stageFlags_ }
      , layout{ layout_ }
      , set{ set_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindDescriptorBufferEmbeddedSamplersInfoEXT( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindDescriptorBufferEmbeddedSamplersInfoEXT( VkBindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindDescriptorBufferEmbeddedSamplersInfoEXT( *reinterpret_cast<BindDescriptorBufferEmbeddedSamplersInfoEXT const *>( &rhs ) )
    {
    }

    BindDescriptorBufferEmbeddedSamplersInfoEXT & operator=( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindDescriptorBufferEmbeddedSamplersInfoEXT & operator=( VkBindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindDescriptorBufferEmbeddedSamplersInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      stageFlags = stageFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      stageFlags = stageFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT
    {
      set = set_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT
    {
      set = set_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT const *>( this );
    }

    operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( this );
    }

    operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT const *>( this );
    }

    operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, ShaderStageFlags const &, PipelineLayout const &, uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, stageFlags, layout, set );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindDescriptorBufferEmbeddedSamplersInfoEXT const & ) const = default;
#else
    bool operator==( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( set == rhs.set );
#  endif
    }

    bool operator!=( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType      = StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT;
    void const *     pNext      = {};
    ShaderStageFlags stageFlags = {};
    PipelineLayout   layout     = {};
    uint32_t         set        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>
  {
    using Type = BindDescriptorBufferEmbeddedSamplersInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT>
  {
    using Type = BindDescriptorBufferEmbeddedSamplersInfoEXT;
  };

  // wrapper struct for struct VkBindDescriptorSetsInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindDescriptorSetsInfo.html
  struct BindDescriptorSetsInfo
  {
    using NativeType = VkBindDescriptorSetsInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindDescriptorSetsInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindDescriptorSetsInfo( ShaderStageFlags      stageFlags_         = {},
                                                 PipelineLayout        layout_             = {},
                                                 uint32_t              firstSet_           = {},
                                                 uint32_t              descriptorSetCount_ = {},
                                                 DescriptorSet const * pDescriptorSets_    = {},
                                                 uint32_t              dynamicOffsetCount_ = {},
                                                 uint32_t const *      pDynamicOffsets_    = {},
                                                 void const *          pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , stageFlags{ stageFlags_ }
      , layout{ layout_ }
      , firstSet{ firstSet_ }
      , descriptorSetCount{ descriptorSetCount_ }
      , pDescriptorSets{ pDescriptorSets_ }
      , dynamicOffsetCount{ dynamicOffsetCount_ }
      , pDynamicOffsets{ pDynamicOffsets_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindDescriptorSetsInfo( BindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindDescriptorSetsInfo( VkBindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindDescriptorSetsInfo( *reinterpret_cast<BindDescriptorSetsInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindDescriptorSetsInfo( ShaderStageFlags                                     stageFlags_,
                            PipelineLayout                                       layout_,
                            uint32_t                                             firstSet_,
                            ArrayProxyNoTemporaries<DescriptorSet const> const & descriptorSets_,
                            ArrayProxyNoTemporaries<uint32_t const> const &      dynamicOffsets_ = {},
                            void const *                                         pNext_          = nullptr )
      : pNext( pNext_ )
      , stageFlags( stageFlags_ )
      , layout( layout_ )
      , firstSet( firstSet_ )
      , descriptorSetCount( static_cast<uint32_t>( descriptorSets_.size() ) )
      , pDescriptorSets( descriptorSets_.data() )
      , dynamicOffsetCount( static_cast<uint32_t>( dynamicOffsets_.size() ) )
      , pDynamicOffsets( dynamicOffsets_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    BindDescriptorSetsInfo & operator=( BindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindDescriptorSetsInfo & operator=( VkBindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindDescriptorSetsInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      stageFlags = stageFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      stageFlags = stageFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setFirstSet( uint32_t firstSet_ ) & VULKAN_HPP_NOEXCEPT
    {
      firstSet = firstSet_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setFirstSet( uint32_t firstSet_ ) && VULKAN_HPP_NOEXCEPT
    {
      firstSet = firstSet_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorSetCount = descriptorSetCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setDescriptorSetCount( uint32_t descriptorSetCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorSetCount = descriptorSetCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setPDescriptorSets( DescriptorSet const * pDescriptorSets_ ) & VULKAN_HPP_NOEXCEPT
    {
      pDescriptorSets = pDescriptorSets_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setPDescriptorSets( DescriptorSet const * pDescriptorSets_ ) && VULKAN_HPP_NOEXCEPT
    {
      pDescriptorSets = pDescriptorSets_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindDescriptorSetsInfo & setDescriptorSets( ArrayProxyNoTemporaries<DescriptorSet const> const & descriptorSets_ ) VULKAN_HPP_NOEXCEPT
    {
      descriptorSetCount = static_cast<uint32_t>( descriptorSets_.size() );
      pDescriptorSets    = descriptorSets_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setDynamicOffsetCount( uint32_t dynamicOffsetCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      dynamicOffsetCount = dynamicOffsetCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setDynamicOffsetCount( uint32_t dynamicOffsetCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      dynamicOffsetCount = dynamicOffsetCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setPDynamicOffsets( uint32_t const * pDynamicOffsets_ ) & VULKAN_HPP_NOEXCEPT
    {
      pDynamicOffsets = pDynamicOffsets_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setPDynamicOffsets( uint32_t const * pDynamicOffsets_ ) && VULKAN_HPP_NOEXCEPT
    {
      pDynamicOffsets = pDynamicOffsets_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindDescriptorSetsInfo & setDynamicOffsets( ArrayProxyNoTemporaries<uint32_t const> const & dynamicOffsets_ ) VULKAN_HPP_NOEXCEPT
    {
      dynamicOffsetCount = static_cast<uint32_t>( dynamicOffsets_.size() );
      pDynamicOffsets    = dynamicOffsets_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindDescriptorSetsInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindDescriptorSetsInfo const *>( this );
    }

    operator VkBindDescriptorSetsInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindDescriptorSetsInfo *>( this );
    }

    operator VkBindDescriptorSetsInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindDescriptorSetsInfo const *>( this );
    }

    operator VkBindDescriptorSetsInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindDescriptorSetsInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               ShaderStageFlags const &,
               PipelineLayout const &,
               uint32_t const &,
               uint32_t const &,
               DescriptorSet const * const &,
               uint32_t const &,
               uint32_t const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, stageFlags, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindDescriptorSetsInfo const & ) const = default;
#else
    bool operator==( BindDescriptorSetsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( firstSet == rhs.firstSet ) &&
             ( descriptorSetCount == rhs.descriptorSetCount ) && ( pDescriptorSets == rhs.pDescriptorSets ) &&
             ( dynamicOffsetCount == rhs.dynamicOffsetCount ) && ( pDynamicOffsets == rhs.pDynamicOffsets );
#  endif
    }

    bool operator!=( BindDescriptorSetsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType         sType              = StructureType::eBindDescriptorSetsInfo;
    void const *          pNext              = {};
    ShaderStageFlags      stageFlags         = {};
    PipelineLayout        layout             = {};
    uint32_t              firstSet           = {};
    uint32_t              descriptorSetCount = {};
    DescriptorSet const * pDescriptorSets    = {};
    uint32_t              dynamicOffsetCount = {};
    uint32_t const *      pDynamicOffsets    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindDescriptorSetsInfo>
  {
    using Type = BindDescriptorSetsInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindDescriptorSetsInfo>
  {
    using Type = BindDescriptorSetsInfo;
  };

  using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo;

  // wrapper struct for struct VkBindHeapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindHeapInfoEXT.html
  struct BindHeapInfoEXT
  {
    using NativeType = VkBindHeapInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindHeapInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindHeapInfoEXT( DeviceAddressRangeEXT heapRange_           = {},
                                          DeviceSize            reservedRangeOffset_ = {},
                                          DeviceSize            reservedRangeSize_   = {},
                                          void const *          pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , heapRange{ heapRange_ }
      , reservedRangeOffset{ reservedRangeOffset_ }
      , reservedRangeSize{ reservedRangeSize_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindHeapInfoEXT( BindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindHeapInfoEXT( VkBindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : BindHeapInfoEXT( *reinterpret_cast<BindHeapInfoEXT const *>( &rhs ) ) {}

    BindHeapInfoEXT & operator=( BindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindHeapInfoEXT & operator=( VkBindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindHeapInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setHeapRange( DeviceAddressRangeEXT heapRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapRange = heapRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setHeapRange( DeviceAddressRangeEXT heapRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapRange = heapRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setReservedRangeOffset( DeviceSize reservedRangeOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      reservedRangeOffset = reservedRangeOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setReservedRangeOffset( DeviceSize reservedRangeOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      reservedRangeOffset = reservedRangeOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setReservedRangeSize( DeviceSize reservedRangeSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      reservedRangeSize = reservedRangeSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setReservedRangeSize( DeviceSize reservedRangeSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      reservedRangeSize = reservedRangeSize_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindHeapInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindHeapInfoEXT const *>( this );
    }

    operator VkBindHeapInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindHeapInfoEXT *>( this );
    }

    operator VkBindHeapInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindHeapInfoEXT const *>( this );
    }

    operator VkBindHeapInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindHeapInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceAddressRangeEXT const &, DeviceSize const &, DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, heapRange, reservedRangeOffset, reservedRangeSize );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindHeapInfoEXT const & ) const = default;
#else
    bool operator==( BindHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapRange == rhs.heapRange ) && ( reservedRangeOffset == rhs.reservedRangeOffset ) &&
             ( reservedRangeSize == rhs.reservedRangeSize );
#  endif
    }

    bool operator!=( BindHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType         sType               = StructureType::eBindHeapInfoEXT;
    void const *          pNext               = {};
    DeviceAddressRangeEXT heapRange           = {};
    DeviceSize            reservedRangeOffset = {};
    DeviceSize            reservedRangeSize   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindHeapInfoEXT>
  {
    using Type = BindHeapInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindHeapInfoEXT>
  {
    using Type = BindHeapInfoEXT;
  };

  // wrapper struct for struct VkOffset2D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOffset2D.html
  struct Offset2D
  {
    using NativeType = VkOffset2D;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR Offset2D( int32_t x_ = {}, int32_t y_ = {} ) VULKAN_HPP_NOEXCEPT
      : x{ x_ }
      , y{ y_ }
    {
    }

    VULKAN_HPP_CONSTEXPR Offset2D( Offset2D const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    Offset2D( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT : Offset2D( *reinterpret_cast<Offset2D const *>( &rhs ) ) {}

    Offset2D & operator=( Offset2D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    Offset2D & operator=( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<Offset2D const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 Offset2D & setX( int32_t x_ ) & VULKAN_HPP_NOEXCEPT
    {
      x = x_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Offset2D && setX( int32_t x_ ) && VULKAN_HPP_NOEXCEPT
    {
      x = x_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Offset2D & setY( int32_t y_ ) & VULKAN_HPP_NOEXCEPT
    {
      y = y_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Offset2D && setY( int32_t y_ ) && VULKAN_HPP_NOEXCEPT
    {
      y = y_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkOffset2D const *>( this );
    }

    operator VkOffset2D &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkOffset2D *>( this );
    }

    operator VkOffset2D const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkOffset2D const *>( this );
    }

    operator VkOffset2D *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkOffset2D *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<int32_t const &, int32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( x, y );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( Offset2D const & ) const = default;
#else
    bool operator==( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( x == rhs.x ) && ( y == rhs.y );
#  endif
    }

    bool operator!=( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    int32_t x = {};
    int32_t y = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkOffset2D>
  {
    using Type = Offset2D;
  };
#endif

  // wrapper struct for struct VkRect2D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRect2D.html
  struct Rect2D
  {
    using NativeType = VkRect2D;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR Rect2D( Offset2D offset_ = {}, Extent2D extent_ = {} ) VULKAN_HPP_NOEXCEPT
      : offset{ offset_ }
      , extent{ extent_ }
    {
    }

    VULKAN_HPP_CONSTEXPR Rect2D( Rect2D const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    Rect2D( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT : Rect2D( *reinterpret_cast<Rect2D const *>( &rhs ) ) {}

    Rect2D & operator=( Rect2D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    Rect2D & operator=( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<Rect2D const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 Rect2D & setOffset( Offset2D const & offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Rect2D && setOffset( Offset2D const & offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Rect2D & setExtent( Extent2D const & extent_ ) & VULKAN_HPP_NOEXCEPT
    {
      extent = extent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Rect2D && setExtent( Extent2D const & extent_ ) && VULKAN_HPP_NOEXCEPT
    {
      extent = extent_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkRect2D const *>( this );
    }

    operator VkRect2D &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkRect2D *>( this );
    }

    operator VkRect2D const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkRect2D const *>( this );
    }

    operator VkRect2D *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkRect2D *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<Offset2D const &, Extent2D const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( offset, extent );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( Rect2D const & ) const = default;
#else
    bool operator==( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( offset == rhs.offset ) && ( extent == rhs.extent );
#  endif
    }

    bool operator!=( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    Offset2D offset = {};
    Extent2D extent = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkRect2D>
  {
    using Type = Rect2D;
  };
#endif

  // wrapper struct for struct VkBindImageMemoryDeviceGroupInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImageMemoryDeviceGroupInfo.html
  struct BindImageMemoryDeviceGroupInfo
  {
    using NativeType = VkBindImageMemoryDeviceGroupInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindImageMemoryDeviceGroupInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t         deviceIndexCount_             = {},
                                                         uint32_t const * pDeviceIndices_               = {},
                                                         uint32_t         splitInstanceBindRegionCount_ = {},
                                                         Rect2D const *   pSplitInstanceBindRegions_    = {},
                                                         void const *     pNext_                        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , deviceIndexCount{ deviceIndexCount_ }
      , pDeviceIndices{ pDeviceIndices_ }
      , splitInstanceBindRegionCount{ splitInstanceBindRegionCount_ }
      , pSplitInstanceBindRegions{ pSplitInstanceBindRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindImageMemoryDeviceGroupInfo( *reinterpret_cast<BindImageMemoryDeviceGroupInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindImageMemoryDeviceGroupInfo( ArrayProxyNoTemporaries<uint32_t const> const & deviceIndices_,
                                    ArrayProxyNoTemporaries<Rect2D const> const &   splitInstanceBindRegions_ = {},
                                    void const *                                    pNext_                    = nullptr )
      : pNext( pNext_ )
      , deviceIndexCount( static_cast<uint32_t>( deviceIndices_.size() ) )
      , pDeviceIndices( deviceIndices_.data() )
      , splitInstanceBindRegionCount( static_cast<uint32_t>( splitInstanceBindRegions_.size() ) )
      , pSplitInstanceBindRegions( splitInstanceBindRegions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    BindImageMemoryDeviceGroupInfo & operator=( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindImageMemoryDeviceGroupInfo & operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindImageMemoryDeviceGroupInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setDeviceIndexCount( uint32_t deviceIndexCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceIndexCount = deviceIndexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setDeviceIndexCount( uint32_t deviceIndexCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceIndexCount = deviceIndexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setPDeviceIndices( uint32_t const * pDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT
    {
      pDeviceIndices = pDeviceIndices_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setPDeviceIndices( uint32_t const * pDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT
    {
      pDeviceIndices = pDeviceIndices_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindImageMemoryDeviceGroupInfo & setDeviceIndices( ArrayProxyNoTemporaries<uint32_t const> const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT
    {
      deviceIndexCount = static_cast<uint32_t>( deviceIndices_.size() );
      pDeviceIndices   = deviceIndices_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      splitInstanceBindRegionCount = splitInstanceBindRegionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      splitInstanceBindRegionCount = splitInstanceBindRegionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setPSplitInstanceBindRegions( Rect2D const * pSplitInstanceBindRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSplitInstanceBindRegions = pSplitInstanceBindRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setPSplitInstanceBindRegions( Rect2D const * pSplitInstanceBindRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSplitInstanceBindRegions = pSplitInstanceBindRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindImageMemoryDeviceGroupInfo & setSplitInstanceBindRegions( ArrayProxyNoTemporaries<Rect2D const> const & splitInstanceBindRegions_ ) VULKAN_HPP_NOEXCEPT
    {
      splitInstanceBindRegionCount = static_cast<uint32_t>( splitInstanceBindRegions_.size() );
      pSplitInstanceBindRegions    = splitInstanceBindRegions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo const *>( this );
    }

    operator VkBindImageMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo *>( this );
    }

    operator VkBindImageMemoryDeviceGroupInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo const *>( this );
    }

    operator VkBindImageMemoryDeviceGroupInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, uint32_t const * const &, uint32_t const &, Rect2D const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindImageMemoryDeviceGroupInfo const & ) const = default;
#else
    bool operator==( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices ) &&
             ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) && ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions );
#  endif
    }

    bool operator!=( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType                        = StructureType::eBindImageMemoryDeviceGroupInfo;
    void const *     pNext                        = {};
    uint32_t         deviceIndexCount             = {};
    uint32_t const * pDeviceIndices               = {};
    uint32_t         splitInstanceBindRegionCount = {};
    Rect2D const *   pSplitInstanceBindRegions    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindImageMemoryDeviceGroupInfo>
  {
    using Type = BindImageMemoryDeviceGroupInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindImageMemoryDeviceGroupInfo>
  {
    using Type = BindImageMemoryDeviceGroupInfo;
  };

  using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;

  // wrapper struct for struct VkBindImageMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImageMemoryInfo.html
  struct BindImageMemoryInfo
  {
    using NativeType = VkBindImageMemoryInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindImageMemoryInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      BindImageMemoryInfo( Image image_ = {}, DeviceMemory memory_ = {}, DeviceSize memoryOffset_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , image{ image_ }
      , memory{ memory_ }
      , memoryOffset{ memoryOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT : BindImageMemoryInfo( *reinterpret_cast<BindImageMemoryInfo const *>( &rhs ) )
    {
    }

    BindImageMemoryInfo & operator=( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindImageMemoryInfo & operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindImageMemoryInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindImageMemoryInfo const *>( this );
    }

    operator VkBindImageMemoryInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindImageMemoryInfo *>( this );
    }

    operator VkBindImageMemoryInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindImageMemoryInfo const *>( this );
    }

    operator VkBindImageMemoryInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindImageMemoryInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Image const &, DeviceMemory const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, image, memory, memoryOffset );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindImageMemoryInfo const & ) const = default;
#else
    bool operator==( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset );
#  endif
    }

    bool operator!=( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType        = StructureType::eBindImageMemoryInfo;
    void const *  pNext        = {};
    Image         image        = {};
    DeviceMemory  memory       = {};
    DeviceSize    memoryOffset = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindImageMemoryInfo>
  {
    using Type = BindImageMemoryInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindImageMemoryInfo>
  {
    using Type = BindImageMemoryInfo;
  };

  using BindImageMemoryInfoKHR = BindImageMemoryInfo;

  // wrapper struct for struct VkBindImageMemorySwapchainInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImageMemorySwapchainInfoKHR.html
  struct BindImageMemorySwapchainInfoKHR
  {
    using NativeType = VkBindImageMemorySwapchainInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindImageMemorySwapchainInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      BindImageMemorySwapchainInfoKHR( SwapchainKHR swapchain_ = {}, uint32_t imageIndex_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , swapchain{ swapchain_ }
      , imageIndex{ imageIndex_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindImageMemorySwapchainInfoKHR( *reinterpret_cast<BindImageMemorySwapchainInfoKHR const *>( &rhs ) )
    {
    }

    BindImageMemorySwapchainInfoKHR & operator=( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindImageMemorySwapchainInfoKHR & operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindImageMemorySwapchainInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT
    {
      swapchain = swapchain_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT
    {
      swapchain = swapchain_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR & setImageIndex( uint32_t imageIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageIndex = imageIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR && setImageIndex( uint32_t imageIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageIndex = imageIndex_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR const *>( this );
    }

    operator VkBindImageMemorySwapchainInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR *>( this );
    }

    operator VkBindImageMemorySwapchainInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR const *>( this );
    }

    operator VkBindImageMemorySwapchainInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, SwapchainKHR const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, swapchain, imageIndex );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindImageMemorySwapchainInfoKHR const & ) const = default;
#else
    bool operator==( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( imageIndex == rhs.imageIndex );
#  endif
    }

    bool operator!=( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType      = StructureType::eBindImageMemorySwapchainInfoKHR;
    void const *  pNext      = {};
    SwapchainKHR  swapchain  = {};
    uint32_t      imageIndex = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindImageMemorySwapchainInfoKHR>
  {
    using Type = BindImageMemorySwapchainInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindImageMemorySwapchainInfoKHR>
  {
    using Type = BindImageMemorySwapchainInfoKHR;
  };

  // wrapper struct for struct VkBindImagePlaneMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImagePlaneMemoryInfo.html
  struct BindImagePlaneMemoryInfo
  {
    using NativeType = VkBindImagePlaneMemoryInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindImagePlaneMemoryInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor,
                                                   void const *        pNext_       = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , planeAspect{ planeAspect_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindImagePlaneMemoryInfo( *reinterpret_cast<BindImagePlaneMemoryInfo const *>( &rhs ) )
    {
    }

    BindImagePlaneMemoryInfo & operator=( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindImagePlaneMemoryInfo & operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindImagePlaneMemoryInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ ) & VULKAN_HPP_NOEXCEPT
    {
      planeAspect = planeAspect_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo && setPlaneAspect( ImageAspectFlagBits planeAspect_ ) && VULKAN_HPP_NOEXCEPT
    {
      planeAspect = planeAspect_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindImagePlaneMemoryInfo const *>( this );
    }

    operator VkBindImagePlaneMemoryInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindImagePlaneMemoryInfo *>( this );
    }

    operator VkBindImagePlaneMemoryInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindImagePlaneMemoryInfo const *>( this );
    }

    operator VkBindImagePlaneMemoryInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindImagePlaneMemoryInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, ImageAspectFlagBits const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, planeAspect );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindImagePlaneMemoryInfo const & ) const = default;
#else
    bool operator==( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect );
#  endif
    }

    bool operator!=( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType       sType       = StructureType::eBindImagePlaneMemoryInfo;
    void const *        pNext       = {};
    ImageAspectFlagBits planeAspect = ImageAspectFlagBits::eColor;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindImagePlaneMemoryInfo>
  {
    using Type = BindImagePlaneMemoryInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindImagePlaneMemoryInfo>
  {
    using Type = BindImagePlaneMemoryInfo;
  };

  using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;

  // wrapper struct for struct VkBindIndexBuffer3InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindIndexBuffer3InfoKHR.html
  struct BindIndexBuffer3InfoKHR
  {
    using NativeType = VkBindIndexBuffer3InfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindIndexBuffer3InfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindIndexBuffer3InfoKHR( DeviceAddressRangeKHR  addressRange_ = {},
                                                  AddressCommandFlagsKHR addressFlags_ = {},
                                                  IndexType              indexType_    = IndexType::eUint16,
                                                  void const *           pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , addressRange{ addressRange_ }
      , addressFlags{ addressFlags_ }
      , indexType{ indexType_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindIndexBuffer3InfoKHR( BindIndexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindIndexBuffer3InfoKHR( VkBindIndexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindIndexBuffer3InfoKHR( *reinterpret_cast<BindIndexBuffer3InfoKHR const *>( &rhs ) )
    {
    }

    BindIndexBuffer3InfoKHR & operator=( BindIndexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindIndexBuffer3InfoKHR & operator=( VkBindIndexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindIndexBuffer3InfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindIndexBuffer3InfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindIndexBuffer3InfoKHR const *>( this );
    }

    operator VkBindIndexBuffer3InfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindIndexBuffer3InfoKHR *>( this );
    }

    operator VkBindIndexBuffer3InfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindIndexBuffer3InfoKHR const *>( this );
    }

    operator VkBindIndexBuffer3InfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindIndexBuffer3InfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceAddressRangeKHR const &, AddressCommandFlagsKHR const &, IndexType const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, addressRange, addressFlags, indexType );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindIndexBuffer3InfoKHR const & ) const = default;
#else
    bool operator==( BindIndexBuffer3InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ) &&
             ( indexType == rhs.indexType );
#  endif
    }

    bool operator!=( BindIndexBuffer3InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType        = StructureType::eBindIndexBuffer3InfoKHR;
    void const *           pNext        = {};
    DeviceAddressRangeKHR  addressRange = {};
    AddressCommandFlagsKHR addressFlags = {};
    IndexType              indexType    = IndexType::eUint16;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindIndexBuffer3InfoKHR>
  {
    using Type = BindIndexBuffer3InfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindIndexBuffer3InfoKHR>
  {
    using Type = BindIndexBuffer3InfoKHR;
  };

  // wrapper struct for struct VkBindIndexBufferIndirectCommandEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindIndexBufferIndirectCommandEXT.html
  struct BindIndexBufferIndirectCommandEXT
  {
    using NativeType = VkBindIndexBufferIndirectCommandEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      BindIndexBufferIndirectCommandEXT( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, IndexType indexType_ = IndexType::eUint16 ) VULKAN_HPP_NOEXCEPT
      : bufferAddress{ bufferAddress_ }
      , size{ size_ }
      , indexType{ indexType_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandEXT( BindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindIndexBufferIndirectCommandEXT( VkBindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindIndexBufferIndirectCommandEXT( *reinterpret_cast<BindIndexBufferIndirectCommandEXT const *>( &rhs ) )
    {
    }

    BindIndexBufferIndirectCommandEXT & operator=( BindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindIndexBufferIndirectCommandEXT & operator=( VkBindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindIndexBufferIndirectCommandEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferAddress = bufferAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferAddress = bufferAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindIndexBufferIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindIndexBufferIndirectCommandEXT const *>( this );
    }

    operator VkBindIndexBufferIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindIndexBufferIndirectCommandEXT *>( this );
    }

    operator VkBindIndexBufferIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindIndexBufferIndirectCommandEXT const *>( this );
    }

    operator VkBindIndexBufferIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindIndexBufferIndirectCommandEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, uint32_t const &, IndexType const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( bufferAddress, size, indexType );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindIndexBufferIndirectCommandEXT const & ) const = default;
#else
    bool operator==( BindIndexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType );
#  endif
    }

    bool operator!=( BindIndexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress bufferAddress = {};
    uint32_t      size          = {};
    IndexType     indexType     = IndexType::eUint16;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindIndexBufferIndirectCommandEXT>
  {
    using Type = BindIndexBufferIndirectCommandEXT;
  };
#endif

  // wrapper struct for struct VkBindIndexBufferIndirectCommandNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindIndexBufferIndirectCommandNV.html
  struct BindIndexBufferIndirectCommandNV
  {
    using NativeType = VkBindIndexBufferIndirectCommandNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      BindIndexBufferIndirectCommandNV( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, IndexType indexType_ = IndexType::eUint16 ) VULKAN_HPP_NOEXCEPT
      : bufferAddress{ bufferAddress_ }
      , size{ size_ }
      , indexType{ indexType_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandNV( BindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindIndexBufferIndirectCommandNV( VkBindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindIndexBufferIndirectCommandNV( *reinterpret_cast<BindIndexBufferIndirectCommandNV const *>( &rhs ) )
    {
    }

    BindIndexBufferIndirectCommandNV & operator=( BindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindIndexBufferIndirectCommandNV & operator=( VkBindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindIndexBufferIndirectCommandNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferAddress = bufferAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferAddress = bufferAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindIndexBufferIndirectCommandNV const *>( this );
    }

    operator VkBindIndexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindIndexBufferIndirectCommandNV *>( this );
    }

    operator VkBindIndexBufferIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindIndexBufferIndirectCommandNV const *>( this );
    }

    operator VkBindIndexBufferIndirectCommandNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindIndexBufferIndirectCommandNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, uint32_t const &, IndexType const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( bufferAddress, size, indexType );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindIndexBufferIndirectCommandNV const & ) const = default;
#else
    bool operator==( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType );
#  endif
    }

    bool operator!=( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress bufferAddress = {};
    uint32_t      size          = {};
    IndexType     indexType     = IndexType::eUint16;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindIndexBufferIndirectCommandNV>
  {
    using Type = BindIndexBufferIndirectCommandNV;
  };
#endif

  // wrapper struct for struct VkBindMemoryStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindMemoryStatus.html
  struct BindMemoryStatus
  {
    using NativeType = VkBindMemoryStatus;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindMemoryStatus;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindMemoryStatus( Result * pResult_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pResult{ pResult_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindMemoryStatus( BindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindMemoryStatus( VkBindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT : BindMemoryStatus( *reinterpret_cast<BindMemoryStatus const *>( &rhs ) ) {}

    BindMemoryStatus & operator=( BindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindMemoryStatus & operator=( VkBindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindMemoryStatus const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus & setPResult( Result * pResult_ ) & VULKAN_HPP_NOEXCEPT
    {
      pResult = pResult_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus && setPResult( Result * pResult_ ) && VULKAN_HPP_NOEXCEPT
    {
      pResult = pResult_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindMemoryStatus const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindMemoryStatus const *>( this );
    }

    operator VkBindMemoryStatus &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindMemoryStatus *>( this );
    }

    operator VkBindMemoryStatus const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindMemoryStatus const *>( this );
    }

    operator VkBindMemoryStatus *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindMemoryStatus *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Result * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pResult );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindMemoryStatus const & ) const = default;
#else
    bool operator==( BindMemoryStatus const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pResult == rhs.pResult );
#  endif
    }

    bool operator!=( BindMemoryStatus const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType   = StructureType::eBindMemoryStatus;
    void const *  pNext   = {};
    Result *      pResult = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindMemoryStatus>
  {
    using Type = BindMemoryStatus;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindMemoryStatus>
  {
    using Type = BindMemoryStatus;
  };

  using BindMemoryStatusKHR = BindMemoryStatus;

  // wrapper struct for struct VkBindPipelineIndirectCommandNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindPipelineIndirectCommandNV.html
  struct BindPipelineIndirectCommandNV
  {
    using NativeType = VkBindPipelineIndirectCommandNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindPipelineIndirectCommandNV( DeviceAddress pipelineAddress_ = {} ) VULKAN_HPP_NOEXCEPT : pipelineAddress{ pipelineAddress_ } {}

    VULKAN_HPP_CONSTEXPR BindPipelineIndirectCommandNV( BindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindPipelineIndirectCommandNV( VkBindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindPipelineIndirectCommandNV( *reinterpret_cast<BindPipelineIndirectCommandNV const *>( &rhs ) )
    {
    }

    BindPipelineIndirectCommandNV & operator=( BindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindPipelineIndirectCommandNV & operator=( VkBindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindPipelineIndirectCommandNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindPipelineIndirectCommandNV & setPipelineAddress( DeviceAddress pipelineAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      pipelineAddress = pipelineAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindPipelineIndirectCommandNV && setPipelineAddress( DeviceAddress pipelineAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      pipelineAddress = pipelineAddress_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindPipelineIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindPipelineIndirectCommandNV const *>( this );
    }

    operator VkBindPipelineIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindPipelineIndirectCommandNV *>( this );
    }

    operator VkBindPipelineIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindPipelineIndirectCommandNV const *>( this );
    }

    operator VkBindPipelineIndirectCommandNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindPipelineIndirectCommandNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( pipelineAddress );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindPipelineIndirectCommandNV const & ) const = default;
#else
    bool operator==( BindPipelineIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( pipelineAddress == rhs.pipelineAddress );
#  endif
    }

    bool operator!=( BindPipelineIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress pipelineAddress = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindPipelineIndirectCommandNV>
  {
    using Type = BindPipelineIndirectCommandNV;
  };
#endif

  // wrapper struct for struct VkBindShaderGroupIndirectCommandNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindShaderGroupIndirectCommandNV.html
  struct BindShaderGroupIndirectCommandNV
  {
    using NativeType = VkBindShaderGroupIndirectCommandNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( uint32_t groupIndex_ = {} ) VULKAN_HPP_NOEXCEPT : groupIndex{ groupIndex_ } {}

    VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( BindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindShaderGroupIndirectCommandNV( VkBindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindShaderGroupIndirectCommandNV( *reinterpret_cast<BindShaderGroupIndirectCommandNV const *>( &rhs ) )
    {
    }

    BindShaderGroupIndirectCommandNV & operator=( BindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindShaderGroupIndirectCommandNV & operator=( VkBindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindShaderGroupIndirectCommandNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindShaderGroupIndirectCommandNV & setGroupIndex( uint32_t groupIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      groupIndex = groupIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindShaderGroupIndirectCommandNV && setGroupIndex( uint32_t groupIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      groupIndex = groupIndex_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindShaderGroupIndirectCommandNV const *>( this );
    }

    operator VkBindShaderGroupIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindShaderGroupIndirectCommandNV *>( this );
    }

    operator VkBindShaderGroupIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindShaderGroupIndirectCommandNV const *>( this );
    }

    operator VkBindShaderGroupIndirectCommandNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindShaderGroupIndirectCommandNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( groupIndex );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindShaderGroupIndirectCommandNV const & ) const = default;
#else
    bool operator==( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( groupIndex == rhs.groupIndex );
#  endif
    }

    bool operator!=( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t groupIndex = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindShaderGroupIndirectCommandNV>
  {
    using Type = BindShaderGroupIndirectCommandNV;
  };
#endif

  // wrapper struct for struct VkSparseMemoryBind, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseMemoryBind.html
  struct SparseMemoryBind
  {
    using NativeType = VkSparseMemoryBind;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SparseMemoryBind( DeviceSize            resourceOffset_ = {},
                                           DeviceSize            size_           = {},
                                           DeviceMemory          memory_         = {},
                                           DeviceSize            memoryOffset_   = {},
                                           SparseMemoryBindFlags flags_          = {} ) VULKAN_HPP_NOEXCEPT
      : resourceOffset{ resourceOffset_ }
      , size{ size_ }
      , memory{ memory_ }
      , memoryOffset{ memoryOffset_ }
      , flags{ flags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SparseMemoryBind( SparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SparseMemoryBind( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT : SparseMemoryBind( *reinterpret_cast<SparseMemoryBind const *>( &rhs ) ) {}

    SparseMemoryBind & operator=( SparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SparseMemoryBind & operator=( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SparseMemoryBind const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setResourceOffset( DeviceSize resourceOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      resourceOffset = resourceOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setResourceOffset( DeviceSize resourceOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      resourceOffset = resourceOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setFlags( SparseMemoryBindFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setFlags( SparseMemoryBindFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseMemoryBind const *>( this );
    }

    operator VkSparseMemoryBind &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseMemoryBind *>( this );
    }

    operator VkSparseMemoryBind const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseMemoryBind const *>( this );
    }

    operator VkSparseMemoryBind *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseMemoryBind *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceSize const &, DeviceSize const &, DeviceMemory const &, DeviceSize const &, SparseMemoryBindFlags const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( resourceOffset, size, memory, memoryOffset, flags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SparseMemoryBind const & ) const = default;
#else
    bool operator==( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( resourceOffset == rhs.resourceOffset ) && ( size == rhs.size ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) &&
             ( flags == rhs.flags );
#  endif
    }

    bool operator!=( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceSize            resourceOffset = {};
    DeviceSize            size           = {};
    DeviceMemory          memory         = {};
    DeviceSize            memoryOffset   = {};
    SparseMemoryBindFlags flags          = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSparseMemoryBind>
  {
    using Type = SparseMemoryBind;
  };
#endif

  // wrapper struct for struct VkSparseBufferMemoryBindInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseBufferMemoryBindInfo.html
  struct SparseBufferMemoryBindInfo
  {
    using NativeType = VkSparseBufferMemoryBindInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( Buffer buffer_ = {}, uint32_t bindCount_ = {}, SparseMemoryBind const * pBinds_ = {} ) VULKAN_HPP_NOEXCEPT
      : buffer{ buffer_ }
      , bindCount{ bindCount_ }
      , pBinds{ pBinds_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( SparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : SparseBufferMemoryBindInfo( *reinterpret_cast<SparseBufferMemoryBindInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    SparseBufferMemoryBindInfo( Buffer buffer_, ArrayProxyNoTemporaries<SparseMemoryBind const> const & binds_ )
      : buffer( buffer_ ), bindCount( static_cast<uint32_t>( binds_.size() ) ), pBinds( binds_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    SparseBufferMemoryBindInfo & operator=( SparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SparseBufferMemoryBindInfo & operator=( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SparseBufferMemoryBindInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo & setBindCount( uint32_t bindCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      bindCount = bindCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo && setBindCount( uint32_t bindCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      bindCount = bindCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo & setPBinds( SparseMemoryBind const * pBinds_ ) & VULKAN_HPP_NOEXCEPT
    {
      pBinds = pBinds_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo && setPBinds( SparseMemoryBind const * pBinds_ ) && VULKAN_HPP_NOEXCEPT
    {
      pBinds = pBinds_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    SparseBufferMemoryBindInfo & setBinds( ArrayProxyNoTemporaries<SparseMemoryBind const> const & binds_ ) VULKAN_HPP_NOEXCEPT
    {
      bindCount = static_cast<uint32_t>( binds_.size() );
      pBinds    = binds_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseBufferMemoryBindInfo const *>( this );
    }

    operator VkSparseBufferMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseBufferMemoryBindInfo *>( this );
    }

    operator VkSparseBufferMemoryBindInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseBufferMemoryBindInfo const *>( this );
    }

    operator VkSparseBufferMemoryBindInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseBufferMemoryBindInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<Buffer const &, uint32_t const &, SparseMemoryBind const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( buffer, bindCount, pBinds );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SparseBufferMemoryBindInfo const & ) const = default;
#else
    bool operator==( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( buffer == rhs.buffer ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
#  endif
    }

    bool operator!=( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    Buffer                   buffer    = {};
    uint32_t                 bindCount = {};
    SparseMemoryBind const * pBinds    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSparseBufferMemoryBindInfo>
  {
    using Type = SparseBufferMemoryBindInfo;
  };
#endif

  // wrapper struct for struct VkSparseImageOpaqueMemoryBindInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageOpaqueMemoryBindInfo.html
  struct SparseImageOpaqueMemoryBindInfo
  {
    using NativeType = VkSparseImageOpaqueMemoryBindInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      SparseImageOpaqueMemoryBindInfo( Image image_ = {}, uint32_t bindCount_ = {}, SparseMemoryBind const * pBinds_ = {} ) VULKAN_HPP_NOEXCEPT
      : image{ image_ }
      , bindCount{ bindCount_ }
      , pBinds{ pBinds_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SparseImageOpaqueMemoryBindInfo( SparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : SparseImageOpaqueMemoryBindInfo( *reinterpret_cast<SparseImageOpaqueMemoryBindInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    SparseImageOpaqueMemoryBindInfo( Image image_, ArrayProxyNoTemporaries<SparseMemoryBind const> const & binds_ )
      : image( image_ ), bindCount( static_cast<uint32_t>( binds_.size() ) ), pBinds( binds_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    SparseImageOpaqueMemoryBindInfo & operator=( SparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SparseImageOpaqueMemoryBindInfo & operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SparseImageOpaqueMemoryBindInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo & setBindCount( uint32_t bindCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      bindCount = bindCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo && setBindCount( uint32_t bindCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      bindCount = bindCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo & setPBinds( SparseMemoryBind const * pBinds_ ) & VULKAN_HPP_NOEXCEPT
    {
      pBinds = pBinds_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo && setPBinds( SparseMemoryBind const * pBinds_ ) && VULKAN_HPP_NOEXCEPT
    {
      pBinds = pBinds_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    SparseImageOpaqueMemoryBindInfo & setBinds( ArrayProxyNoTemporaries<SparseMemoryBind const> const & binds_ ) VULKAN_HPP_NOEXCEPT
    {
      bindCount = static_cast<uint32_t>( binds_.size() );
      pBinds    = binds_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const *>( this );
    }

    operator VkSparseImageOpaqueMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>( this );
    }

    operator VkSparseImageOpaqueMemoryBindInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const *>( this );
    }

    operator VkSparseImageOpaqueMemoryBindInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<Image const &, uint32_t const &, SparseMemoryBind const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( image, bindCount, pBinds );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SparseImageOpaqueMemoryBindInfo const & ) const = default;
#else
    bool operator==( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
#  endif
    }

    bool operator!=( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    Image                    image     = {};
    uint32_t                 bindCount = {};
    SparseMemoryBind const * pBinds    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSparseImageOpaqueMemoryBindInfo>
  {
    using Type = SparseImageOpaqueMemoryBindInfo;
  };
#endif

  // wrapper struct for struct VkImageSubresource, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresource.html
  struct ImageSubresource
  {
    using NativeType = VkImageSubresource;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ImageSubresource( ImageAspectFlags aspectMask_ = {}, uint32_t mipLevel_ = {}, uint32_t arrayLayer_ = {} ) VULKAN_HPP_NOEXCEPT
      : aspectMask{ aspectMask_ }
      , mipLevel{ mipLevel_ }
      , arrayLayer{ arrayLayer_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ImageSubresource( ImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ImageSubresource( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT : ImageSubresource( *reinterpret_cast<ImageSubresource const *>( &rhs ) ) {}

    ImageSubresource & operator=( ImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ImageSubresource & operator=( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ImageSubresource const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ImageSubresource & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresource && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresource & setMipLevel( uint32_t mipLevel_ ) & VULKAN_HPP_NOEXCEPT
    {
      mipLevel = mipLevel_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresource && setMipLevel( uint32_t mipLevel_ ) && VULKAN_HPP_NOEXCEPT
    {
      mipLevel = mipLevel_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresource & setArrayLayer( uint32_t arrayLayer_ ) & VULKAN_HPP_NOEXCEPT
    {
      arrayLayer = arrayLayer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresource && setArrayLayer( uint32_t arrayLayer_ ) && VULKAN_HPP_NOEXCEPT
    {
      arrayLayer = arrayLayer_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageSubresource const *>( this );
    }

    operator VkImageSubresource &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageSubresource *>( this );
    }

    operator VkImageSubresource const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageSubresource const *>( this );
    }

    operator VkImageSubresource *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageSubresource *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<ImageAspectFlags const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( aspectMask, mipLevel, arrayLayer );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ImageSubresource const & ) const = default;
#else
    bool operator==( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( arrayLayer == rhs.arrayLayer );
#  endif
    }

    bool operator!=( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    ImageAspectFlags aspectMask = {};
    uint32_t         mipLevel   = {};
    uint32_t         arrayLayer = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkImageSubresource>
  {
    using Type = ImageSubresource;
  };
#endif

  // wrapper struct for struct VkOffset3D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOffset3D.html
  struct Offset3D
  {
    using NativeType = VkOffset3D;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR Offset3D( int32_t x_ = {}, int32_t y_ = {}, int32_t z_ = {} ) VULKAN_HPP_NOEXCEPT
      : x{ x_ }
      , y{ y_ }
      , z{ z_ }
    {
    }

    VULKAN_HPP_CONSTEXPR Offset3D( Offset3D const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    Offset3D( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT : Offset3D( *reinterpret_cast<Offset3D const *>( &rhs ) ) {}

    explicit Offset3D( Offset2D const & offset2D, int32_t z_ = {} ) : x( offset2D.x ), y( offset2D.y ), z( z_ ) {}

    Offset3D & operator=( Offset3D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    Offset3D & operator=( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<Offset3D const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 Offset3D & setX( int32_t x_ ) & VULKAN_HPP_NOEXCEPT
    {
      x = x_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Offset3D && setX( int32_t x_ ) && VULKAN_HPP_NOEXCEPT
    {
      x = x_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Offset3D & setY( int32_t y_ ) & VULKAN_HPP_NOEXCEPT
    {
      y = y_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Offset3D && setY( int32_t y_ ) && VULKAN_HPP_NOEXCEPT
    {
      y = y_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Offset3D & setZ( int32_t z_ ) & VULKAN_HPP_NOEXCEPT
    {
      z = z_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Offset3D && setZ( int32_t z_ ) && VULKAN_HPP_NOEXCEPT
    {
      z = z_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkOffset3D const *>( this );
    }

    operator VkOffset3D &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkOffset3D *>( this );
    }

    operator VkOffset3D const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkOffset3D const *>( this );
    }

    operator VkOffset3D *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkOffset3D *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<int32_t const &, int32_t const &, int32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( x, y, z );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( Offset3D const & ) const = default;
#else
    bool operator==( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z );
#  endif
    }

    bool operator!=( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    int32_t x = {};
    int32_t y = {};
    int32_t z = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkOffset3D>
  {
    using Type = Offset3D;
  };
#endif

  // wrapper struct for struct VkExtent3D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExtent3D.html
  struct Extent3D
  {
    using NativeType = VkExtent3D;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR Extent3D( uint32_t width_ = {}, uint32_t height_ = {}, uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT
      : width{ width_ }
      , height{ height_ }
      , depth{ depth_ }
    {
    }

    VULKAN_HPP_CONSTEXPR Extent3D( Extent3D const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    Extent3D( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT : Extent3D( *reinterpret_cast<Extent3D const *>( &rhs ) ) {}

    explicit Extent3D( Extent2D const & extent2D, uint32_t depth_ = {} ) : width( extent2D.width ), height( extent2D.height ), depth( depth_ ) {}

    Extent3D & operator=( Extent3D const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    Extent3D & operator=( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<Extent3D const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 Extent3D & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT
    {
      width = width_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Extent3D && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT
    {
      width = width_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Extent3D & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT
    {
      height = height_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Extent3D && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT
    {
      height = height_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Extent3D & setDepth( uint32_t depth_ ) & VULKAN_HPP_NOEXCEPT
    {
      depth = depth_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Extent3D && setDepth( uint32_t depth_ ) && VULKAN_HPP_NOEXCEPT
    {
      depth = depth_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkExtent3D const *>( this );
    }

    operator VkExtent3D &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkExtent3D *>( this );
    }

    operator VkExtent3D const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkExtent3D const *>( this );
    }

    operator VkExtent3D *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkExtent3D *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( width, height, depth );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( Extent3D const & ) const = default;
#else
    bool operator==( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth );
#  endif
    }

    bool operator!=( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t width  = {};
    uint32_t height = {};
    uint32_t depth  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkExtent3D>
  {
    using Type = Extent3D;
  };
#endif

  // wrapper struct for struct VkSparseImageMemoryBind, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryBind.html
  struct SparseImageMemoryBind
  {
    using NativeType = VkSparseImageMemoryBind;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( ImageSubresource      subresource_  = {},
                                                Offset3D              offset_       = {},
                                                Extent3D              extent_       = {},
                                                DeviceMemory          memory_       = {},
                                                DeviceSize            memoryOffset_ = {},
                                                SparseMemoryBindFlags flags_        = {} ) VULKAN_HPP_NOEXCEPT
      : subresource{ subresource_ }
      , offset{ offset_ }
      , extent{ extent_ }
      , memory{ memory_ }
      , memoryOffset{ memoryOffset_ }
      , flags{ flags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( SparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
      : SparseImageMemoryBind( *reinterpret_cast<SparseImageMemoryBind const *>( &rhs ) )
    {
    }

    SparseImageMemoryBind & operator=( SparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SparseImageMemoryBind & operator=( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SparseImageMemoryBind const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setSubresource( ImageSubresource const & subresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      subresource = subresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setSubresource( ImageSubresource const & subresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      subresource = subresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setOffset( Offset3D const & offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setOffset( Offset3D const & offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT
    {
      extent = extent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT
    {
      extent = extent_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setFlags( SparseMemoryBindFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setFlags( SparseMemoryBindFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseImageMemoryBind const *>( this );
    }

    operator VkSparseImageMemoryBind &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseImageMemoryBind *>( this );
    }

    operator VkSparseImageMemoryBind const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseImageMemoryBind const *>( this );
    }

    operator VkSparseImageMemoryBind *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseImageMemoryBind *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<ImageSubresource const &, Offset3D const &, Extent3D const &, DeviceMemory const &, DeviceSize const &, SparseMemoryBindFlags const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( subresource, offset, extent, memory, memoryOffset, flags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SparseImageMemoryBind const & ) const = default;
#else
    bool operator==( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( subresource == rhs.subresource ) && ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( memory == rhs.memory ) &&
             ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags );
#  endif
    }

    bool operator!=( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    ImageSubresource      subresource  = {};
    Offset3D              offset       = {};
    Extent3D              extent       = {};
    DeviceMemory          memory       = {};
    DeviceSize            memoryOffset = {};
    SparseMemoryBindFlags flags        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSparseImageMemoryBind>
  {
    using Type = SparseImageMemoryBind;
  };
#endif

  // wrapper struct for struct VkSparseImageMemoryBindInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryBindInfo.html
  struct SparseImageMemoryBindInfo
  {
    using NativeType = VkSparseImageMemoryBindInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      SparseImageMemoryBindInfo( Image image_ = {}, uint32_t bindCount_ = {}, SparseImageMemoryBind const * pBinds_ = {} ) VULKAN_HPP_NOEXCEPT
      : image{ image_ }
      , bindCount{ bindCount_ }
      , pBinds{ pBinds_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SparseImageMemoryBindInfo( SparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : SparseImageMemoryBindInfo( *reinterpret_cast<SparseImageMemoryBindInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    SparseImageMemoryBindInfo( Image image_, ArrayProxyNoTemporaries<SparseImageMemoryBind const> const & binds_ )
      : image( image_ ), bindCount( static_cast<uint32_t>( binds_.size() ) ), pBinds( binds_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    SparseImageMemoryBindInfo & operator=( SparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SparseImageMemoryBindInfo & operator=( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SparseImageMemoryBindInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo & setBindCount( uint32_t bindCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      bindCount = bindCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo && setBindCount( uint32_t bindCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      bindCount = bindCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo & setPBinds( SparseImageMemoryBind const * pBinds_ ) & VULKAN_HPP_NOEXCEPT
    {
      pBinds = pBinds_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo && setPBinds( SparseImageMemoryBind const * pBinds_ ) && VULKAN_HPP_NOEXCEPT
    {
      pBinds = pBinds_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    SparseImageMemoryBindInfo & setBinds( ArrayProxyNoTemporaries<SparseImageMemoryBind const> const & binds_ ) VULKAN_HPP_NOEXCEPT
    {
      bindCount = static_cast<uint32_t>( binds_.size() );
      pBinds    = binds_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseImageMemoryBindInfo const *>( this );
    }

    operator VkSparseImageMemoryBindInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSparseImageMemoryBindInfo *>( this );
    }

    operator VkSparseImageMemoryBindInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseImageMemoryBindInfo const *>( this );
    }

    operator VkSparseImageMemoryBindInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSparseImageMemoryBindInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<Image const &, uint32_t const &, SparseImageMemoryBind const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( image, bindCount, pBinds );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SparseImageMemoryBindInfo const & ) const = default;
#else
    bool operator==( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
#  endif
    }

    bool operator!=( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    Image                         image     = {};
    uint32_t                      bindCount = {};
    SparseImageMemoryBind const * pBinds    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSparseImageMemoryBindInfo>
  {
    using Type = SparseImageMemoryBindInfo;
  };
#endif

  // wrapper struct for struct VkBindSparseInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindSparseInfo.html
  struct BindSparseInfo
  {
    using NativeType = VkBindSparseInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindSparseInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t                                waitSemaphoreCount_   = {},
                                         Semaphore const *                       pWaitSemaphores_      = {},
                                         uint32_t                                bufferBindCount_      = {},
                                         SparseBufferMemoryBindInfo const *      pBufferBinds_         = {},
                                         uint32_t                                imageOpaqueBindCount_ = {},
                                         SparseImageOpaqueMemoryBindInfo const * pImageOpaqueBinds_    = {},
                                         uint32_t                                imageBindCount_       = {},
                                         SparseImageMemoryBindInfo const *       pImageBinds_          = {},
                                         uint32_t                                signalSemaphoreCount_ = {},
                                         Semaphore const *                       pSignalSemaphores_    = {},
                                         void const *                            pNext_                = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , waitSemaphoreCount{ waitSemaphoreCount_ }
      , pWaitSemaphores{ pWaitSemaphores_ }
      , bufferBindCount{ bufferBindCount_ }
      , pBufferBinds{ pBufferBinds_ }
      , imageOpaqueBindCount{ imageOpaqueBindCount_ }
      , pImageOpaqueBinds{ pImageOpaqueBinds_ }
      , imageBindCount{ imageBindCount_ }
      , pImageBinds{ pImageBinds_ }
      , signalSemaphoreCount{ signalSemaphoreCount_ }
      , pSignalSemaphores{ pSignalSemaphores_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindSparseInfo( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT : BindSparseInfo( *reinterpret_cast<BindSparseInfo const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindSparseInfo( ArrayProxyNoTemporaries<Semaphore const> const &                       waitSemaphores_,
                    ArrayProxyNoTemporaries<SparseBufferMemoryBindInfo const> const &      bufferBinds_      = {},
                    ArrayProxyNoTemporaries<SparseImageOpaqueMemoryBindInfo const> const & imageOpaqueBinds_ = {},
                    ArrayProxyNoTemporaries<SparseImageMemoryBindInfo const> const &       imageBinds_       = {},
                    ArrayProxyNoTemporaries<Semaphore const> const &                       signalSemaphores_ = {},
                    void const *                                                           pNext_            = nullptr )
      : pNext( pNext_ )
      , waitSemaphoreCount( static_cast<uint32_t>( waitSemaphores_.size() ) )
      , pWaitSemaphores( waitSemaphores_.data() )
      , bufferBindCount( static_cast<uint32_t>( bufferBinds_.size() ) )
      , pBufferBinds( bufferBinds_.data() )
      , imageOpaqueBindCount( static_cast<uint32_t>( imageOpaqueBinds_.size() ) )
      , pImageOpaqueBinds( imageOpaqueBinds_.data() )
      , imageBindCount( static_cast<uint32_t>( imageBinds_.size() ) )
      , pImageBinds( imageBinds_.data() )
      , signalSemaphoreCount( static_cast<uint32_t>( signalSemaphores_.size() ) )
      , pSignalSemaphores( signalSemaphores_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    BindSparseInfo & operator=( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindSparseInfo & operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindSparseInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      waitSemaphoreCount = waitSemaphoreCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      waitSemaphoreCount = waitSemaphoreCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPWaitSemaphores( Semaphore const * pWaitSemaphores_ ) & VULKAN_HPP_NOEXCEPT
    {
      pWaitSemaphores = pWaitSemaphores_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPWaitSemaphores( Semaphore const * pWaitSemaphores_ ) && VULKAN_HPP_NOEXCEPT
    {
      pWaitSemaphores = pWaitSemaphores_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindSparseInfo & setWaitSemaphores( ArrayProxyNoTemporaries<Semaphore const> const & waitSemaphores_ ) VULKAN_HPP_NOEXCEPT
    {
      waitSemaphoreCount = static_cast<uint32_t>( waitSemaphores_.size() );
      pWaitSemaphores    = waitSemaphores_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setBufferBindCount( uint32_t bufferBindCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferBindCount = bufferBindCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setBufferBindCount( uint32_t bufferBindCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferBindCount = bufferBindCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPBufferBinds( SparseBufferMemoryBindInfo const * pBufferBinds_ ) & VULKAN_HPP_NOEXCEPT
    {
      pBufferBinds = pBufferBinds_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPBufferBinds( SparseBufferMemoryBindInfo const * pBufferBinds_ ) && VULKAN_HPP_NOEXCEPT
    {
      pBufferBinds = pBufferBinds_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindSparseInfo & setBufferBinds( ArrayProxyNoTemporaries<SparseBufferMemoryBindInfo const> const & bufferBinds_ ) VULKAN_HPP_NOEXCEPT
    {
      bufferBindCount = static_cast<uint32_t>( bufferBinds_.size() );
      pBufferBinds    = bufferBinds_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageOpaqueBindCount = imageOpaqueBindCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageOpaqueBindCount = imageOpaqueBindCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPImageOpaqueBinds( SparseImageOpaqueMemoryBindInfo const * pImageOpaqueBinds_ ) & VULKAN_HPP_NOEXCEPT
    {
      pImageOpaqueBinds = pImageOpaqueBinds_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPImageOpaqueBinds( SparseImageOpaqueMemoryBindInfo const * pImageOpaqueBinds_ ) && VULKAN_HPP_NOEXCEPT
    {
      pImageOpaqueBinds = pImageOpaqueBinds_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindSparseInfo & setImageOpaqueBinds( ArrayProxyNoTemporaries<SparseImageOpaqueMemoryBindInfo const> const & imageOpaqueBinds_ ) VULKAN_HPP_NOEXCEPT
    {
      imageOpaqueBindCount = static_cast<uint32_t>( imageOpaqueBinds_.size() );
      pImageOpaqueBinds    = imageOpaqueBinds_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setImageBindCount( uint32_t imageBindCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageBindCount = imageBindCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setImageBindCount( uint32_t imageBindCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageBindCount = imageBindCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPImageBinds( SparseImageMemoryBindInfo const * pImageBinds_ ) & VULKAN_HPP_NOEXCEPT
    {
      pImageBinds = pImageBinds_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPImageBinds( SparseImageMemoryBindInfo const * pImageBinds_ ) && VULKAN_HPP_NOEXCEPT
    {
      pImageBinds = pImageBinds_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindSparseInfo & setImageBinds( ArrayProxyNoTemporaries<SparseImageMemoryBindInfo const> const & imageBinds_ ) VULKAN_HPP_NOEXCEPT
    {
      imageBindCount = static_cast<uint32_t>( imageBinds_.size() );
      pImageBinds    = imageBinds_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      signalSemaphoreCount = signalSemaphoreCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      signalSemaphoreCount = signalSemaphoreCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPSignalSemaphores( Semaphore const * pSignalSemaphores_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSignalSemaphores = pSignalSemaphores_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPSignalSemaphores( Semaphore const * pSignalSemaphores_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSignalSemaphores = pSignalSemaphores_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BindSparseInfo & setSignalSemaphores( ArrayProxyNoTemporaries<Semaphore const> const & signalSemaphores_ ) VULKAN_HPP_NOEXCEPT
    {
      signalSemaphoreCount = static_cast<uint32_t>( signalSemaphores_.size() );
      pSignalSemaphores    = signalSemaphores_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindSparseInfo const *>( this );
    }

    operator VkBindSparseInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindSparseInfo *>( this );
    }

    operator VkBindSparseInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindSparseInfo const *>( this );
    }

    operator VkBindSparseInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindSparseInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               uint32_t const &,
               Semaphore const * const &,
               uint32_t const &,
               SparseBufferMemoryBindInfo const * const &,
               uint32_t const &,
               SparseImageOpaqueMemoryBindInfo const * const &,
               uint32_t const &,
               SparseImageMemoryBindInfo const * const &,
               uint32_t const &,
               Semaphore const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       waitSemaphoreCount,
                       pWaitSemaphores,
                       bufferBindCount,
                       pBufferBinds,
                       imageOpaqueBindCount,
                       pImageOpaqueBinds,
                       imageBindCount,
                       pImageBinds,
                       signalSemaphoreCount,
                       pSignalSemaphores );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindSparseInfo const & ) const = default;
#else
    bool operator==( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
             ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( bufferBindCount == rhs.bufferBindCount ) && ( pBufferBinds == rhs.pBufferBinds ) &&
             ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) &&
             ( imageBindCount == rhs.imageBindCount ) && ( pImageBinds == rhs.pImageBinds ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) &&
             ( pSignalSemaphores == rhs.pSignalSemaphores );
#  endif
    }

    bool operator!=( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                           sType                = StructureType::eBindSparseInfo;
    void const *                            pNext                = {};
    uint32_t                                waitSemaphoreCount   = {};
    Semaphore const *                       pWaitSemaphores      = {};
    uint32_t                                bufferBindCount      = {};
    SparseBufferMemoryBindInfo const *      pBufferBinds         = {};
    uint32_t                                imageOpaqueBindCount = {};
    SparseImageOpaqueMemoryBindInfo const * pImageOpaqueBinds    = {};
    uint32_t                                imageBindCount       = {};
    SparseImageMemoryBindInfo const *       pImageBinds          = {};
    uint32_t                                signalSemaphoreCount = {};
    Semaphore const *                       pSignalSemaphores    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindSparseInfo>
  {
    using Type = BindSparseInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindSparseInfo>
  {
    using Type = BindSparseInfo;
  };

  // wrapper struct for struct VkBindTensorMemoryInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindTensorMemoryInfoARM.html
  struct BindTensorMemoryInfoARM
  {
    using NativeType = VkBindTensorMemoryInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindTensorMemoryInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindTensorMemoryInfoARM( TensorARM    tensor_       = {},
                                                  DeviceMemory memory_       = {},
                                                  DeviceSize   memoryOffset_ = {},
                                                  void const * pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , tensor{ tensor_ }
      , memory{ memory_ }
      , memoryOffset{ memoryOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindTensorMemoryInfoARM( BindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindTensorMemoryInfoARM( VkBindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindTensorMemoryInfoARM( *reinterpret_cast<BindTensorMemoryInfoARM const *>( &rhs ) )
    {
    }

    BindTensorMemoryInfoARM & operator=( BindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindTensorMemoryInfoARM & operator=( VkBindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindTensorMemoryInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT
    {
      tensor = tensor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT
    {
      tensor = tensor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindTensorMemoryInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindTensorMemoryInfoARM const *>( this );
    }

    operator VkBindTensorMemoryInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindTensorMemoryInfoARM *>( this );
    }

    operator VkBindTensorMemoryInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindTensorMemoryInfoARM const *>( this );
    }

    operator VkBindTensorMemoryInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindTensorMemoryInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, TensorARM const &, DeviceMemory const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, tensor, memory, memoryOffset );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindTensorMemoryInfoARM const & ) const = default;
#else
    bool operator==( BindTensorMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensor == rhs.tensor ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset );
#  endif
    }

    bool operator!=( BindTensorMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType        = StructureType::eBindTensorMemoryInfoARM;
    void const *  pNext        = {};
    TensorARM     tensor       = {};
    DeviceMemory  memory       = {};
    DeviceSize    memoryOffset = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindTensorMemoryInfoARM>
  {
    using Type = BindTensorMemoryInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindTensorMemoryInfoARM>
  {
    using Type = BindTensorMemoryInfoARM;
  };

  // wrapper struct for struct VkBindTransformFeedbackBuffer2InfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindTransformFeedbackBuffer2InfoEXT.html
  struct BindTransformFeedbackBuffer2InfoEXT
  {
    using NativeType = VkBindTransformFeedbackBuffer2InfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindTransformFeedbackBuffer2InfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindTransformFeedbackBuffer2InfoEXT( DeviceAddressRangeKHR  addressRange_ = {},
                                                              AddressCommandFlagsKHR addressFlags_ = {},
                                                              void const *           pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , addressRange{ addressRange_ }
      , addressFlags{ addressFlags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindTransformFeedbackBuffer2InfoEXT( BindTransformFeedbackBuffer2InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindTransformFeedbackBuffer2InfoEXT( VkBindTransformFeedbackBuffer2InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindTransformFeedbackBuffer2InfoEXT( *reinterpret_cast<BindTransformFeedbackBuffer2InfoEXT const *>( &rhs ) )
    {
    }

    BindTransformFeedbackBuffer2InfoEXT & operator=( BindTransformFeedbackBuffer2InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindTransformFeedbackBuffer2InfoEXT & operator=( VkBindTransformFeedbackBuffer2InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindTransformFeedbackBuffer2InfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindTransformFeedbackBuffer2InfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindTransformFeedbackBuffer2InfoEXT const *>( this );
    }

    operator VkBindTransformFeedbackBuffer2InfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindTransformFeedbackBuffer2InfoEXT *>( this );
    }

    operator VkBindTransformFeedbackBuffer2InfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindTransformFeedbackBuffer2InfoEXT const *>( this );
    }

    operator VkBindTransformFeedbackBuffer2InfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindTransformFeedbackBuffer2InfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceAddressRangeKHR const &, AddressCommandFlagsKHR const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, addressRange, addressFlags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindTransformFeedbackBuffer2InfoEXT const & ) const = default;
#else
    bool operator==( BindTransformFeedbackBuffer2InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags );
#  endif
    }

    bool operator!=( BindTransformFeedbackBuffer2InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType        = StructureType::eBindTransformFeedbackBuffer2InfoEXT;
    void const *           pNext        = {};
    DeviceAddressRangeKHR  addressRange = {};
    AddressCommandFlagsKHR addressFlags = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindTransformFeedbackBuffer2InfoEXT>
  {
    using Type = BindTransformFeedbackBuffer2InfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindTransformFeedbackBuffer2InfoEXT>
  {
    using Type = BindTransformFeedbackBuffer2InfoEXT;
  };

  // wrapper struct for struct VkStridedDeviceAddressRangeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressRangeKHR.html
  struct StridedDeviceAddressRangeKHR
  {
    using NativeType = VkStridedDeviceAddressRangeKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( DeviceAddress address_ = {}, DeviceSize size_ = {}, DeviceSize stride_ = {} ) VULKAN_HPP_NOEXCEPT
      : address{ address_ }
      , size{ size_ }
      , stride{ stride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    StridedDeviceAddressRangeKHR( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : StridedDeviceAddressRangeKHR( *reinterpret_cast<StridedDeviceAddressRangeKHR const *>( &rhs ) )
    {
    }

    StridedDeviceAddressRangeKHR & operator=( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    StridedDeviceAddressRangeKHR & operator=( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<StridedDeviceAddressRangeKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT
    {
      address = address_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT
    {
      address = address_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkStridedDeviceAddressRangeKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkStridedDeviceAddressRangeKHR const *>( this );
    }

    operator VkStridedDeviceAddressRangeKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkStridedDeviceAddressRangeKHR *>( this );
    }

    operator VkStridedDeviceAddressRangeKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkStridedDeviceAddressRangeKHR const *>( this );
    }

    operator VkStridedDeviceAddressRangeKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkStridedDeviceAddressRangeKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, DeviceSize const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( address, size, stride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( StridedDeviceAddressRangeKHR const & ) const = default;
#else
    bool operator==( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( address == rhs.address ) && ( size == rhs.size ) && ( stride == rhs.stride );
#  endif
    }

    bool operator!=( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress address = {};
    DeviceSize    size    = {};
    DeviceSize    stride  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkStridedDeviceAddressRangeKHR>
  {
    using Type = StridedDeviceAddressRangeKHR;
  };
#endif

  // wrapper struct for struct VkBindVertexBuffer3InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVertexBuffer3InfoKHR.html
  struct BindVertexBuffer3InfoKHR
  {
    using NativeType = VkBindVertexBuffer3InfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindVertexBuffer3InfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindVertexBuffer3InfoKHR( Bool32                       setStride_    = {},
                                                   StridedDeviceAddressRangeKHR addressRange_ = {},
                                                   AddressCommandFlagsKHR       addressFlags_ = {},
                                                   void const *                 pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , setStride{ setStride_ }
      , addressRange{ addressRange_ }
      , addressFlags{ addressFlags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindVertexBuffer3InfoKHR( BindVertexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindVertexBuffer3InfoKHR( VkBindVertexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindVertexBuffer3InfoKHR( *reinterpret_cast<BindVertexBuffer3InfoKHR const *>( &rhs ) )
    {
    }

    BindVertexBuffer3InfoKHR & operator=( BindVertexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindVertexBuffer3InfoKHR & operator=( VkBindVertexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindVertexBuffer3InfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR & setSetStride( Bool32 setStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      setStride = setStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR && setSetStride( Bool32 setStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      setStride = setStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR & setAddressRange( StridedDeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR && setAddressRange( StridedDeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindVertexBuffer3InfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindVertexBuffer3InfoKHR const *>( this );
    }

    operator VkBindVertexBuffer3InfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindVertexBuffer3InfoKHR *>( this );
    }

    operator VkBindVertexBuffer3InfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindVertexBuffer3InfoKHR const *>( this );
    }

    operator VkBindVertexBuffer3InfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindVertexBuffer3InfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &, StridedDeviceAddressRangeKHR const &, AddressCommandFlagsKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, setStride, addressRange, addressFlags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindVertexBuffer3InfoKHR const & ) const = default;
#else
    bool operator==( BindVertexBuffer3InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( setStride == rhs.setStride ) && ( addressRange == rhs.addressRange ) &&
             ( addressFlags == rhs.addressFlags );
#  endif
    }

    bool operator!=( BindVertexBuffer3InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                sType        = StructureType::eBindVertexBuffer3InfoKHR;
    void const *                 pNext        = {};
    Bool32                       setStride    = {};
    StridedDeviceAddressRangeKHR addressRange = {};
    AddressCommandFlagsKHR       addressFlags = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindVertexBuffer3InfoKHR>
  {
    using Type = BindVertexBuffer3InfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindVertexBuffer3InfoKHR>
  {
    using Type = BindVertexBuffer3InfoKHR;
  };

  // wrapper struct for struct VkBindVertexBufferIndirectCommandEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVertexBufferIndirectCommandEXT.html
  struct BindVertexBufferIndirectCommandEXT
  {
    using NativeType = VkBindVertexBufferIndirectCommandEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandEXT( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, uint32_t stride_ = {} ) VULKAN_HPP_NOEXCEPT
      : bufferAddress{ bufferAddress_ }
      , size{ size_ }
      , stride{ stride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandEXT( BindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindVertexBufferIndirectCommandEXT( VkBindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindVertexBufferIndirectCommandEXT( *reinterpret_cast<BindVertexBufferIndirectCommandEXT const *>( &rhs ) )
    {
    }

    BindVertexBufferIndirectCommandEXT & operator=( BindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindVertexBufferIndirectCommandEXT & operator=( VkBindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindVertexBufferIndirectCommandEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferAddress = bufferAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferAddress = bufferAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindVertexBufferIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindVertexBufferIndirectCommandEXT const *>( this );
    }

    operator VkBindVertexBufferIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindVertexBufferIndirectCommandEXT *>( this );
    }

    operator VkBindVertexBufferIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindVertexBufferIndirectCommandEXT const *>( this );
    }

    operator VkBindVertexBufferIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindVertexBufferIndirectCommandEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( bufferAddress, size, stride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindVertexBufferIndirectCommandEXT const & ) const = default;
#else
    bool operator==( BindVertexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride );
#  endif
    }

    bool operator!=( BindVertexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress bufferAddress = {};
    uint32_t      size          = {};
    uint32_t      stride        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindVertexBufferIndirectCommandEXT>
  {
    using Type = BindVertexBufferIndirectCommandEXT;
  };
#endif

  // wrapper struct for struct VkBindVertexBufferIndirectCommandNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVertexBufferIndirectCommandNV.html
  struct BindVertexBufferIndirectCommandNV
  {
    using NativeType = VkBindVertexBufferIndirectCommandNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, uint32_t stride_ = {} ) VULKAN_HPP_NOEXCEPT
      : bufferAddress{ bufferAddress_ }
      , size{ size_ }
      , stride{ stride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( BindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindVertexBufferIndirectCommandNV( VkBindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindVertexBufferIndirectCommandNV( *reinterpret_cast<BindVertexBufferIndirectCommandNV const *>( &rhs ) )
    {
    }

    BindVertexBufferIndirectCommandNV & operator=( BindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindVertexBufferIndirectCommandNV & operator=( VkBindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindVertexBufferIndirectCommandNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferAddress = bufferAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferAddress = bufferAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindVertexBufferIndirectCommandNV const *>( this );
    }

    operator VkBindVertexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindVertexBufferIndirectCommandNV *>( this );
    }

    operator VkBindVertexBufferIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindVertexBufferIndirectCommandNV const *>( this );
    }

    operator VkBindVertexBufferIndirectCommandNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindVertexBufferIndirectCommandNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( bufferAddress, size, stride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindVertexBufferIndirectCommandNV const & ) const = default;
#else
    bool operator==( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride );
#  endif
    }

    bool operator!=( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress bufferAddress = {};
    uint32_t      size          = {};
    uint32_t      stride        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindVertexBufferIndirectCommandNV>
  {
    using Type = BindVertexBufferIndirectCommandNV;
  };
#endif

  // wrapper struct for struct VkBindVideoSessionMemoryInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVideoSessionMemoryInfoKHR.html
  struct BindVideoSessionMemoryInfoKHR
  {
    using NativeType = VkBindVideoSessionMemoryInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBindVideoSessionMemoryInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BindVideoSessionMemoryInfoKHR( uint32_t     memoryBindIndex_ = {},
                                                        DeviceMemory memory_          = {},
                                                        DeviceSize   memoryOffset_    = {},
                                                        DeviceSize   memorySize_      = {},
                                                        void const * pNext_           = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , memoryBindIndex{ memoryBindIndex_ }
      , memory{ memory_ }
      , memoryOffset{ memoryOffset_ }
      , memorySize{ memorySize_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BindVideoSessionMemoryInfoKHR( BindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BindVideoSessionMemoryInfoKHR( VkBindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : BindVideoSessionMemoryInfoKHR( *reinterpret_cast<BindVideoSessionMemoryInfoKHR const *>( &rhs ) )
    {
    }

    BindVideoSessionMemoryInfoKHR & operator=( BindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BindVideoSessionMemoryInfoKHR & operator=( VkBindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BindVideoSessionMemoryInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemoryBindIndex( uint32_t memoryBindIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryBindIndex = memoryBindIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemoryBindIndex( uint32_t memoryBindIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryBindIndex = memoryBindIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT
    {
      memory = memory_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryOffset = memoryOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemorySize( DeviceSize memorySize_ ) & VULKAN_HPP_NOEXCEPT
    {
      memorySize = memorySize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemorySize( DeviceSize memorySize_ ) && VULKAN_HPP_NOEXCEPT
    {
      memorySize = memorySize_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBindVideoSessionMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindVideoSessionMemoryInfoKHR const *>( this );
    }

    operator VkBindVideoSessionMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBindVideoSessionMemoryInfoKHR *>( this );
    }

    operator VkBindVideoSessionMemoryInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindVideoSessionMemoryInfoKHR const *>( this );
    }

    operator VkBindVideoSessionMemoryInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBindVideoSessionMemoryInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, DeviceMemory const &, DeviceSize const &, DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BindVideoSessionMemoryInfoKHR const & ) const = default;
#else
    bool operator==( BindVideoSessionMemoryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && ( memory == rhs.memory ) &&
             ( memoryOffset == rhs.memoryOffset ) && ( memorySize == rhs.memorySize );
#  endif
    }

    bool operator!=( BindVideoSessionMemoryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType           = StructureType::eBindVideoSessionMemoryInfoKHR;
    void const *  pNext           = {};
    uint32_t      memoryBindIndex = {};
    DeviceMemory  memory          = {};
    DeviceSize    memoryOffset    = {};
    DeviceSize    memorySize      = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBindVideoSessionMemoryInfoKHR>
  {
    using Type = BindVideoSessionMemoryInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBindVideoSessionMemoryInfoKHR>
  {
    using Type = BindVideoSessionMemoryInfoKHR;
  };

  // wrapper struct for struct VkBlitImageCubicWeightsInfoQCOM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlitImageCubicWeightsInfoQCOM.html
  struct BlitImageCubicWeightsInfoQCOM
  {
    using NativeType = VkBlitImageCubicWeightsInfoQCOM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBlitImageCubicWeightsInfoQCOM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BlitImageCubicWeightsInfoQCOM( CubicFilterWeightsQCOM cubicWeights_ = CubicFilterWeightsQCOM::eCatmullRom,
                                                        void const *           pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , cubicWeights{ cubicWeights_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BlitImageCubicWeightsInfoQCOM( BlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BlitImageCubicWeightsInfoQCOM( VkBlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
      : BlitImageCubicWeightsInfoQCOM( *reinterpret_cast<BlitImageCubicWeightsInfoQCOM const *>( &rhs ) )
    {
    }

    BlitImageCubicWeightsInfoQCOM & operator=( BlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BlitImageCubicWeightsInfoQCOM & operator=( VkBlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BlitImageCubicWeightsInfoQCOM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM & setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) & VULKAN_HPP_NOEXCEPT
    {
      cubicWeights = cubicWeights_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM && setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) && VULKAN_HPP_NOEXCEPT
    {
      cubicWeights = cubicWeights_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBlitImageCubicWeightsInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBlitImageCubicWeightsInfoQCOM const *>( this );
    }

    operator VkBlitImageCubicWeightsInfoQCOM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBlitImageCubicWeightsInfoQCOM *>( this );
    }

    operator VkBlitImageCubicWeightsInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBlitImageCubicWeightsInfoQCOM const *>( this );
    }

    operator VkBlitImageCubicWeightsInfoQCOM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBlitImageCubicWeightsInfoQCOM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, CubicFilterWeightsQCOM const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, cubicWeights );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BlitImageCubicWeightsInfoQCOM const & ) const = default;
#else
    bool operator==( BlitImageCubicWeightsInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicWeights == rhs.cubicWeights );
#  endif
    }

    bool operator!=( BlitImageCubicWeightsInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType        = StructureType::eBlitImageCubicWeightsInfoQCOM;
    void const *           pNext        = {};
    CubicFilterWeightsQCOM cubicWeights = CubicFilterWeightsQCOM::eCatmullRom;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBlitImageCubicWeightsInfoQCOM>
  {
    using Type = BlitImageCubicWeightsInfoQCOM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBlitImageCubicWeightsInfoQCOM>
  {
    using Type = BlitImageCubicWeightsInfoQCOM;
  };

  // wrapper struct for struct VkImageSubresourceLayers, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresourceLayers.html
  struct ImageSubresourceLayers
  {
    using NativeType = VkImageSubresourceLayers;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( ImageAspectFlags aspectMask_     = {},
                                                 uint32_t         mipLevel_       = {},
                                                 uint32_t         baseArrayLayer_ = {},
                                                 uint32_t         layerCount_     = {} ) VULKAN_HPP_NOEXCEPT
      : aspectMask{ aspectMask_ }
      , mipLevel{ mipLevel_ }
      , baseArrayLayer{ baseArrayLayer_ }
      , layerCount{ layerCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( ImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
      : ImageSubresourceLayers( *reinterpret_cast<ImageSubresourceLayers const *>( &rhs ) )
    {
    }

    ImageSubresourceLayers & operator=( ImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ImageSubresourceLayers & operator=( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ImageSubresourceLayers const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setMipLevel( uint32_t mipLevel_ ) & VULKAN_HPP_NOEXCEPT
    {
      mipLevel = mipLevel_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setMipLevel( uint32_t mipLevel_ ) && VULKAN_HPP_NOEXCEPT
    {
      mipLevel = mipLevel_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT
    {
      baseArrayLayer = baseArrayLayer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT
    {
      baseArrayLayer = baseArrayLayer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      layerCount = layerCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      layerCount = layerCount_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageSubresourceLayers const *>( this );
    }

    operator VkImageSubresourceLayers &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageSubresourceLayers *>( this );
    }

    operator VkImageSubresourceLayers const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageSubresourceLayers const *>( this );
    }

    operator VkImageSubresourceLayers *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageSubresourceLayers *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<ImageAspectFlags const &, uint32_t const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( aspectMask, mipLevel, baseArrayLayer, layerCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ImageSubresourceLayers const & ) const = default;
#else
    bool operator==( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount );
#  endif
    }

    bool operator!=( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    ImageAspectFlags aspectMask     = {};
    uint32_t         mipLevel       = {};
    uint32_t         baseArrayLayer = {};
    uint32_t         layerCount     = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkImageSubresourceLayers>
  {
    using Type = ImageSubresourceLayers;
  };
#endif

  // wrapper struct for struct VkImageBlit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageBlit2.html
  struct ImageBlit2
  {
    using NativeType = VkImageBlit2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eImageBlit2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 ImageBlit2( ImageSubresourceLayers          srcSubresource_ = {},
                                        std::array<Offset3D, 2> const & srcOffsets_     = {},
                                        ImageSubresourceLayers          dstSubresource_ = {},
                                        std::array<Offset3D, 2> const & dstOffsets_     = {},
                                        void const *                    pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcSubresource{ srcSubresource_ }
      , srcOffsets{ srcOffsets_ }
      , dstSubresource{ dstSubresource_ }
      , dstOffsets{ dstOffsets_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2( ImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ImageBlit2( VkImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageBlit2( *reinterpret_cast<ImageBlit2 const *>( &rhs ) ) {}

    ImageBlit2 & operator=( ImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ImageBlit2 & operator=( VkImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ImageBlit2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcSubresource = srcSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcSubresource = srcSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setSrcOffsets( std::array<Offset3D, 2> const & srcOffsets_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcOffsets = srcOffsets_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setSrcOffsets( std::array<Offset3D, 2> const & srcOffsets_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcOffsets = srcOffsets_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstSubresource = dstSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstSubresource = dstSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setDstOffsets( std::array<Offset3D, 2> const & dstOffsets_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstOffsets = dstOffsets_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setDstOffsets( std::array<Offset3D, 2> const & dstOffsets_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstOffsets = dstOffsets_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkImageBlit2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageBlit2 const *>( this );
    }

    operator VkImageBlit2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageBlit2 *>( this );
    }

    operator VkImageBlit2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageBlit2 const *>( this );
    }

    operator VkImageBlit2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageBlit2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               ImageSubresourceLayers const &,
               ArrayWrapper1D<Offset3D, 2> const &,
               ImageSubresourceLayers const &,
               ArrayWrapper1D<Offset3D, 2> const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ImageBlit2 const & ) const = default;
#else
    bool operator==( ImageBlit2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) &&
             ( dstSubresource == rhs.dstSubresource ) && ( dstOffsets == rhs.dstOffsets );
#  endif
    }

    bool operator!=( ImageBlit2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType               sType          = StructureType::eImageBlit2;
    void const *                pNext          = {};
    ImageSubresourceLayers      srcSubresource = {};
    ArrayWrapper1D<Offset3D, 2> srcOffsets     = {};
    ImageSubresourceLayers      dstSubresource = {};
    ArrayWrapper1D<Offset3D, 2> dstOffsets     = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkImageBlit2>
  {
    using Type = ImageBlit2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eImageBlit2>
  {
    using Type = ImageBlit2;
  };

  using ImageBlit2KHR = ImageBlit2;

  // wrapper struct for struct VkBlitImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlitImageInfo2.html
  struct BlitImageInfo2
  {
    using NativeType = VkBlitImageInfo2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBlitImageInfo2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2( Image              srcImage_       = {},
                                            ImageLayout        srcImageLayout_ = ImageLayout::eUndefined,
                                            Image              dstImage_       = {},
                                            ImageLayout        dstImageLayout_ = ImageLayout::eUndefined,
                                            uint32_t           regionCount_    = {},
                                            ImageBlit2 const * pRegions_       = {},
                                            Filter             filter_         = Filter::eNearest,
                                            void const *       pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcImage{ srcImage_ }
      , srcImageLayout{ srcImageLayout_ }
      , dstImage{ dstImage_ }
      , dstImageLayout{ dstImageLayout_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
      , filter{ filter_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2( BlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BlitImageInfo2( VkBlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : BlitImageInfo2( *reinterpret_cast<BlitImageInfo2 const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BlitImageInfo2( Image                                             srcImage_,
                    ImageLayout                                       srcImageLayout_,
                    Image                                             dstImage_,
                    ImageLayout                                       dstImageLayout_,
                    ArrayProxyNoTemporaries<ImageBlit2 const> const & regions_,
                    Filter                                            filter_ = Filter::eNearest,
                    void const *                                      pNext_  = nullptr )
      : pNext( pNext_ )
      , srcImage( srcImage_ )
      , srcImageLayout( srcImageLayout_ )
      , dstImage( dstImage_ )
      , dstImageLayout( dstImageLayout_ )
      , regionCount( static_cast<uint32_t>( regions_.size() ) )
      , pRegions( regions_.data() )
      , filter( filter_ )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    BlitImageInfo2 & operator=( BlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BlitImageInfo2 & operator=( VkBlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BlitImageInfo2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setPRegions( ImageBlit2 const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setPRegions( ImageBlit2 const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BlitImageInfo2 & setRegions( ArrayProxyNoTemporaries<ImageBlit2 const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setFilter( Filter filter_ ) & VULKAN_HPP_NOEXCEPT
    {
      filter = filter_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setFilter( Filter filter_ ) && VULKAN_HPP_NOEXCEPT
    {
      filter = filter_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBlitImageInfo2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBlitImageInfo2 const *>( this );
    }

    operator VkBlitImageInfo2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBlitImageInfo2 *>( this );
    }

    operator VkBlitImageInfo2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBlitImageInfo2 const *>( this );
    }

    operator VkBlitImageInfo2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBlitImageInfo2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               Image const &,
               ImageLayout const &,
               Image const &,
               ImageLayout const &,
               uint32_t const &,
               ImageBlit2 const * const &,
               Filter const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BlitImageInfo2 const & ) const = default;
#else
    bool operator==( BlitImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) &&
             ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ) &&
             ( filter == rhs.filter );
#  endif
    }

    bool operator!=( BlitImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType      sType          = StructureType::eBlitImageInfo2;
    void const *       pNext          = {};
    Image              srcImage       = {};
    ImageLayout        srcImageLayout = ImageLayout::eUndefined;
    Image              dstImage       = {};
    ImageLayout        dstImageLayout = ImageLayout::eUndefined;
    uint32_t           regionCount    = {};
    ImageBlit2 const * pRegions       = {};
    Filter             filter         = Filter::eNearest;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBlitImageInfo2>
  {
    using Type = BlitImageInfo2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBlitImageInfo2>
  {
    using Type = BlitImageInfo2;
  };

  using BlitImageInfo2KHR = BlitImageInfo2;

  // wrapper struct for struct VkBufferCaptureDescriptorDataInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCaptureDescriptorDataInfoEXT.html
  struct BufferCaptureDescriptorDataInfoEXT
  {
    using NativeType = VkBufferCaptureDescriptorDataInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferCaptureDescriptorDataInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferCaptureDescriptorDataInfoEXT( Buffer buffer_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , buffer{ buffer_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferCaptureDescriptorDataInfoEXT( BufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferCaptureDescriptorDataInfoEXT( VkBufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferCaptureDescriptorDataInfoEXT( *reinterpret_cast<BufferCaptureDescriptorDataInfoEXT const *>( &rhs ) )
    {
    }

    BufferCaptureDescriptorDataInfoEXT & operator=( BufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferCaptureDescriptorDataInfoEXT & operator=( VkBufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferCaptureDescriptorDataInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCaptureDescriptorDataInfoEXT const *>( this );
    }

    operator VkBufferCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCaptureDescriptorDataInfoEXT *>( this );
    }

    operator VkBufferCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCaptureDescriptorDataInfoEXT const *>( this );
    }

    operator VkBufferCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCaptureDescriptorDataInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Buffer const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, buffer );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferCaptureDescriptorDataInfoEXT const & ) const = default;
#else
    bool operator==( BufferCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
#  endif
    }

    bool operator!=( BufferCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType  = StructureType::eBufferCaptureDescriptorDataInfoEXT;
    void const *  pNext  = {};
    Buffer        buffer = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferCaptureDescriptorDataInfoEXT>
  {
    using Type = BufferCaptureDescriptorDataInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferCaptureDescriptorDataInfoEXT>
  {
    using Type = BufferCaptureDescriptorDataInfoEXT;
  };

#if defined( VK_USE_PLATFORM_FUCHSIA )
  // wrapper struct for struct VkBufferCollectionBufferCreateInfoFUCHSIA, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionBufferCreateInfoFUCHSIA.html
  struct BufferCollectionBufferCreateInfoFUCHSIA
  {
    using NativeType = VkBufferCollectionBufferCreateInfoFUCHSIA;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferCollectionBufferCreateInfoFUCHSIA;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferCollectionBufferCreateInfoFUCHSIA( BufferCollectionFUCHSIA collection_ = {},
                                                                  uint32_t                index_      = {},
                                                                  void const *            pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , collection{ collection_ }
      , index{ index_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferCollectionBufferCreateInfoFUCHSIA( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferCollectionBufferCreateInfoFUCHSIA( VkBufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferCollectionBufferCreateInfoFUCHSIA( *reinterpret_cast<BufferCollectionBufferCreateInfoFUCHSIA const *>( &rhs ) )
    {
    }

    BufferCollectionBufferCreateInfoFUCHSIA & operator=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferCollectionBufferCreateInfoFUCHSIA & operator=( VkBufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferCollectionBufferCreateInfoFUCHSIA const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA & setCollection( BufferCollectionFUCHSIA collection_ ) & VULKAN_HPP_NOEXCEPT
    {
      collection = collection_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA && setCollection( BufferCollectionFUCHSIA collection_ ) && VULKAN_HPP_NOEXCEPT
    {
      collection = collection_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT
    {
      index = index_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT
    {
      index = index_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferCollectionBufferCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA const *>( this );
    }

    operator VkBufferCollectionBufferCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA *>( this );
    }

    operator VkBufferCollectionBufferCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA const *>( this );
    }

    operator VkBufferCollectionBufferCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, BufferCollectionFUCHSIA const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, collection, index );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferCollectionBufferCreateInfoFUCHSIA const & ) const = default;
#  else
    bool operator==( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index );
#    endif
    }

    bool operator!=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType           sType      = StructureType::eBufferCollectionBufferCreateInfoFUCHSIA;
    void const *            pNext      = {};
    BufferCollectionFUCHSIA collection = {};
    uint32_t                index      = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferCollectionBufferCreateInfoFUCHSIA>
  {
    using Type = BufferCollectionBufferCreateInfoFUCHSIA;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eBufferCollectionBufferCreateInfoFUCHSIA>
  {
    using Type = BufferCollectionBufferCreateInfoFUCHSIA;
  };
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined( VK_USE_PLATFORM_FUCHSIA )
  // wrapper struct for struct VkBufferCollectionConstraintsInfoFUCHSIA, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionConstraintsInfoFUCHSIA.html
  struct BufferCollectionConstraintsInfoFUCHSIA
  {
    using NativeType = VkBufferCollectionConstraintsInfoFUCHSIA;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferCollectionConstraintsInfoFUCHSIA;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferCollectionConstraintsInfoFUCHSIA( uint32_t     minBufferCount_                  = {},
                                                                 uint32_t     maxBufferCount_                  = {},
                                                                 uint32_t     minBufferCountForCamping_        = {},
                                                                 uint32_t     minBufferCountForDedicatedSlack_ = {},
                                                                 uint32_t     minBufferCountForSharedSlack_    = {},
                                                                 void const * pNext_                           = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , minBufferCount{ minBufferCount_ }
      , maxBufferCount{ maxBufferCount_ }
      , minBufferCountForCamping{ minBufferCountForCamping_ }
      , minBufferCountForDedicatedSlack{ minBufferCountForDedicatedSlack_ }
      , minBufferCountForSharedSlack{ minBufferCountForSharedSlack_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferCollectionConstraintsInfoFUCHSIA( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferCollectionConstraintsInfoFUCHSIA( VkBufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferCollectionConstraintsInfoFUCHSIA( *reinterpret_cast<BufferCollectionConstraintsInfoFUCHSIA const *>( &rhs ) )
    {
    }

    BufferCollectionConstraintsInfoFUCHSIA & operator=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferCollectionConstraintsInfoFUCHSIA & operator=( VkBufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferCollectionConstraintsInfoFUCHSIA const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCount( uint32_t minBufferCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      minBufferCount = minBufferCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCount( uint32_t minBufferCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      minBufferCount = minBufferCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMaxBufferCount( uint32_t maxBufferCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxBufferCount = maxBufferCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMaxBufferCount( uint32_t maxBufferCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxBufferCount = maxBufferCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCountForCamping( uint32_t minBufferCountForCamping_ ) & VULKAN_HPP_NOEXCEPT
    {
      minBufferCountForCamping = minBufferCountForCamping_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCountForCamping( uint32_t minBufferCountForCamping_ ) && VULKAN_HPP_NOEXCEPT
    {
      minBufferCountForCamping = minBufferCountForCamping_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCountForDedicatedSlack( uint32_t minBufferCountForDedicatedSlack_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      minBufferCountForDedicatedSlack = minBufferCountForDedicatedSlack_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCountForDedicatedSlack( uint32_t minBufferCountForDedicatedSlack_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      minBufferCountForDedicatedSlack = minBufferCountForDedicatedSlack_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCountForSharedSlack( uint32_t minBufferCountForSharedSlack_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      minBufferCountForSharedSlack = minBufferCountForSharedSlack_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCountForSharedSlack( uint32_t minBufferCountForSharedSlack_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      minBufferCountForSharedSlack = minBufferCountForSharedSlack_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferCollectionConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA const *>( this );
    }

    operator VkBufferCollectionConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA *>( this );
    }

    operator VkBufferCollectionConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA const *>( this );
    }

    operator VkBufferCollectionConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, minBufferCount, maxBufferCount, minBufferCountForCamping, minBufferCountForDedicatedSlack, minBufferCountForSharedSlack );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferCollectionConstraintsInfoFUCHSIA const & ) const = default;
#  else
    bool operator==( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) && ( maxBufferCount == rhs.maxBufferCount ) &&
             ( minBufferCountForCamping == rhs.minBufferCountForCamping ) && ( minBufferCountForDedicatedSlack == rhs.minBufferCountForDedicatedSlack ) &&
             ( minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack );
#    endif
    }

    bool operator!=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType sType                           = StructureType::eBufferCollectionConstraintsInfoFUCHSIA;
    void const *  pNext                           = {};
    uint32_t      minBufferCount                  = {};
    uint32_t      maxBufferCount                  = {};
    uint32_t      minBufferCountForCamping        = {};
    uint32_t      minBufferCountForDedicatedSlack = {};
    uint32_t      minBufferCountForSharedSlack    = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferCollectionConstraintsInfoFUCHSIA>
  {
    using Type = BufferCollectionConstraintsInfoFUCHSIA;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eBufferCollectionConstraintsInfoFUCHSIA>
  {
    using Type = BufferCollectionConstraintsInfoFUCHSIA;
  };
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined( VK_USE_PLATFORM_FUCHSIA )
  // wrapper struct for struct VkBufferCollectionCreateInfoFUCHSIA, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionCreateInfoFUCHSIA.html
  struct BufferCollectionCreateInfoFUCHSIA
  {
    using NativeType = VkBufferCollectionCreateInfoFUCHSIA;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferCollectionCreateInfoFUCHSIA;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferCollectionCreateInfoFUCHSIA( zx_handle_t collectionToken_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , collectionToken{ collectionToken_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferCollectionCreateInfoFUCHSIA( BufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferCollectionCreateInfoFUCHSIA( VkBufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferCollectionCreateInfoFUCHSIA( *reinterpret_cast<BufferCollectionCreateInfoFUCHSIA const *>( &rhs ) )
    {
    }

    BufferCollectionCreateInfoFUCHSIA & operator=( BufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferCollectionCreateInfoFUCHSIA & operator=( VkBufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferCollectionCreateInfoFUCHSIA const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA & setCollectionToken( zx_handle_t collectionToken_ ) & VULKAN_HPP_NOEXCEPT
    {
      collectionToken = collectionToken_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA && setCollectionToken( zx_handle_t collectionToken_ ) && VULKAN_HPP_NOEXCEPT
    {
      collectionToken = collectionToken_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferCollectionCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA const *>( this );
    }

    operator VkBufferCollectionCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA *>( this );
    }

    operator VkBufferCollectionCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA const *>( this );
    }

    operator VkBufferCollectionCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, zx_handle_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, collectionToken );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( auto cmp = memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ); cmp != 0 )
        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;

      return std::strong_ordering::equivalent;
    }
#  endif

    bool operator==( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 );
    }

    bool operator!=( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType sType           = StructureType::eBufferCollectionCreateInfoFUCHSIA;
    void const *  pNext           = {};
    zx_handle_t   collectionToken = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferCollectionCreateInfoFUCHSIA>
  {
    using Type = BufferCollectionCreateInfoFUCHSIA;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eBufferCollectionCreateInfoFUCHSIA>
  {
    using Type = BufferCollectionCreateInfoFUCHSIA;
  };
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined( VK_USE_PLATFORM_FUCHSIA )
  // wrapper struct for struct VkBufferCollectionImageCreateInfoFUCHSIA, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionImageCreateInfoFUCHSIA.html
  struct BufferCollectionImageCreateInfoFUCHSIA
  {
    using NativeType = VkBufferCollectionImageCreateInfoFUCHSIA;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferCollectionImageCreateInfoFUCHSIA;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferCollectionImageCreateInfoFUCHSIA( BufferCollectionFUCHSIA collection_ = {},
                                                                 uint32_t                index_      = {},
                                                                 void const *            pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , collection{ collection_ }
      , index{ index_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferCollectionImageCreateInfoFUCHSIA( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferCollectionImageCreateInfoFUCHSIA( VkBufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferCollectionImageCreateInfoFUCHSIA( *reinterpret_cast<BufferCollectionImageCreateInfoFUCHSIA const *>( &rhs ) )
    {
    }

    BufferCollectionImageCreateInfoFUCHSIA & operator=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferCollectionImageCreateInfoFUCHSIA & operator=( VkBufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferCollectionImageCreateInfoFUCHSIA const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA & setCollection( BufferCollectionFUCHSIA collection_ ) & VULKAN_HPP_NOEXCEPT
    {
      collection = collection_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA && setCollection( BufferCollectionFUCHSIA collection_ ) && VULKAN_HPP_NOEXCEPT
    {
      collection = collection_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT
    {
      index = index_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT
    {
      index = index_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferCollectionImageCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA const *>( this );
    }

    operator VkBufferCollectionImageCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA *>( this );
    }

    operator VkBufferCollectionImageCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA const *>( this );
    }

    operator VkBufferCollectionImageCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, BufferCollectionFUCHSIA const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, collection, index );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferCollectionImageCreateInfoFUCHSIA const & ) const = default;
#  else
    bool operator==( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index );
#    endif
    }

    bool operator!=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType           sType      = StructureType::eBufferCollectionImageCreateInfoFUCHSIA;
    void const *            pNext      = {};
    BufferCollectionFUCHSIA collection = {};
    uint32_t                index      = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferCollectionImageCreateInfoFUCHSIA>
  {
    using Type = BufferCollectionImageCreateInfoFUCHSIA;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eBufferCollectionImageCreateInfoFUCHSIA>
  {
    using Type = BufferCollectionImageCreateInfoFUCHSIA;
  };
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined( VK_USE_PLATFORM_FUCHSIA )
  // wrapper struct for struct VkSysmemColorSpaceFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSysmemColorSpaceFUCHSIA.html
  struct SysmemColorSpaceFUCHSIA
  {
    using NativeType = VkSysmemColorSpaceFUCHSIA;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eSysmemColorSpaceFUCHSIA;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SysmemColorSpaceFUCHSIA( uint32_t colorSpace_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , colorSpace{ colorSpace_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SysmemColorSpaceFUCHSIA( SysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SysmemColorSpaceFUCHSIA( VkSysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
      : SysmemColorSpaceFUCHSIA( *reinterpret_cast<SysmemColorSpaceFUCHSIA const *>( &rhs ) )
    {
    }

    SysmemColorSpaceFUCHSIA & operator=( SysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SysmemColorSpaceFUCHSIA & operator=( VkSysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SysmemColorSpaceFUCHSIA const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA & setColorSpace( uint32_t colorSpace_ ) & VULKAN_HPP_NOEXCEPT
    {
      colorSpace = colorSpace_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA && setColorSpace( uint32_t colorSpace_ ) && VULKAN_HPP_NOEXCEPT
    {
      colorSpace = colorSpace_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkSysmemColorSpaceFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSysmemColorSpaceFUCHSIA const *>( this );
    }

    operator VkSysmemColorSpaceFUCHSIA &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSysmemColorSpaceFUCHSIA *>( this );
    }

    operator VkSysmemColorSpaceFUCHSIA const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSysmemColorSpaceFUCHSIA const *>( this );
    }

    operator VkSysmemColorSpaceFUCHSIA *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSysmemColorSpaceFUCHSIA *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, colorSpace );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SysmemColorSpaceFUCHSIA const & ) const = default;
#  else
    bool operator==( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace );
#    endif
    }

    bool operator!=( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType sType      = StructureType::eSysmemColorSpaceFUCHSIA;
    void const *  pNext      = {};
    uint32_t      colorSpace = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSysmemColorSpaceFUCHSIA>
  {
    using Type = SysmemColorSpaceFUCHSIA;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eSysmemColorSpaceFUCHSIA>
  {
    using Type = SysmemColorSpaceFUCHSIA;
  };
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined( VK_USE_PLATFORM_FUCHSIA )
  // wrapper struct for struct VkBufferCollectionPropertiesFUCHSIA, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionPropertiesFUCHSIA.html
  struct BufferCollectionPropertiesFUCHSIA
  {
    using NativeType = VkBufferCollectionPropertiesFUCHSIA;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferCollectionPropertiesFUCHSIA;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferCollectionPropertiesFUCHSIA( uint32_t                    memoryTypeBits_                   = {},
                                                            uint32_t                    bufferCount_                      = {},
                                                            uint32_t                    createInfoIndex_                  = {},
                                                            uint64_t                    sysmemPixelFormat_                = {},
                                                            FormatFeatureFlags          formatFeatures_                   = {},
                                                            SysmemColorSpaceFUCHSIA     sysmemColorSpaceIndex_            = {},
                                                            ComponentMapping            samplerYcbcrConversionComponents_ = {},
                                                            SamplerYcbcrModelConversion suggestedYcbcrModel_    = SamplerYcbcrModelConversion::eRgbIdentity,
                                                            SamplerYcbcrRange           suggestedYcbcrRange_    = SamplerYcbcrRange::eItuFull,
                                                            ChromaLocation              suggestedXChromaOffset_ = ChromaLocation::eCositedEven,
                                                            ChromaLocation              suggestedYChromaOffset_ = ChromaLocation::eCositedEven,
                                                            void *                      pNext_                  = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , memoryTypeBits{ memoryTypeBits_ }
      , bufferCount{ bufferCount_ }
      , createInfoIndex{ createInfoIndex_ }
      , sysmemPixelFormat{ sysmemPixelFormat_ }
      , formatFeatures{ formatFeatures_ }
      , sysmemColorSpaceIndex{ sysmemColorSpaceIndex_ }
      , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ }
      , suggestedYcbcrModel{ suggestedYcbcrModel_ }
      , suggestedYcbcrRange{ suggestedYcbcrRange_ }
      , suggestedXChromaOffset{ suggestedXChromaOffset_ }
      , suggestedYChromaOffset{ suggestedYChromaOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferCollectionPropertiesFUCHSIA( BufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferCollectionPropertiesFUCHSIA( VkBufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferCollectionPropertiesFUCHSIA( *reinterpret_cast<BufferCollectionPropertiesFUCHSIA const *>( &rhs ) )
    {
    }

    BufferCollectionPropertiesFUCHSIA & operator=( BufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferCollectionPropertiesFUCHSIA & operator=( VkBufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferCollectionPropertiesFUCHSIA const *>( &rhs );
      return *this;
    }

    operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA const *>( this );
    }

    operator VkBufferCollectionPropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( this );
    }

    operator VkBufferCollectionPropertiesFUCHSIA const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA const *>( this );
    }

    operator VkBufferCollectionPropertiesFUCHSIA *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint64_t const &,
               FormatFeatureFlags const &,
               SysmemColorSpaceFUCHSIA const &,
               ComponentMapping const &,
               SamplerYcbcrModelConversion const &,
               SamplerYcbcrRange const &,
               ChromaLocation const &,
               ChromaLocation const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       memoryTypeBits,
                       bufferCount,
                       createInfoIndex,
                       sysmemPixelFormat,
                       formatFeatures,
                       sysmemColorSpaceIndex,
                       samplerYcbcrConversionComponents,
                       suggestedYcbcrModel,
                       suggestedYcbcrRange,
                       suggestedXChromaOffset,
                       suggestedYChromaOffset );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferCollectionPropertiesFUCHSIA const & ) const = default;
#  else
    bool operator==( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ) && ( bufferCount == rhs.bufferCount ) &&
             ( createInfoIndex == rhs.createInfoIndex ) && ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( formatFeatures == rhs.formatFeatures ) &&
             ( sysmemColorSpaceIndex == rhs.sysmemColorSpaceIndex ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
             ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
             ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
#    endif
    }

    bool operator!=( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType               sType                            = StructureType::eBufferCollectionPropertiesFUCHSIA;
    void *                      pNext                            = {};
    uint32_t                    memoryTypeBits                   = {};
    uint32_t                    bufferCount                      = {};
    uint32_t                    createInfoIndex                  = {};
    uint64_t                    sysmemPixelFormat                = {};
    FormatFeatureFlags          formatFeatures                   = {};
    SysmemColorSpaceFUCHSIA     sysmemColorSpaceIndex            = {};
    ComponentMapping            samplerYcbcrConversionComponents = {};
    SamplerYcbcrModelConversion suggestedYcbcrModel              = SamplerYcbcrModelConversion::eRgbIdentity;
    SamplerYcbcrRange           suggestedYcbcrRange              = SamplerYcbcrRange::eItuFull;
    ChromaLocation              suggestedXChromaOffset           = ChromaLocation::eCositedEven;
    ChromaLocation              suggestedYChromaOffset           = ChromaLocation::eCositedEven;
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferCollectionPropertiesFUCHSIA>
  {
    using Type = BufferCollectionPropertiesFUCHSIA;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eBufferCollectionPropertiesFUCHSIA>
  {
    using Type = BufferCollectionPropertiesFUCHSIA;
  };
#endif /*VK_USE_PLATFORM_FUCHSIA*/

  // wrapper struct for struct VkBufferCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCreateInfo.html
  struct BufferCreateInfo
  {
    using NativeType = VkBufferCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferCreateInfo( BufferCreateFlags flags_                 = {},
                                           DeviceSize        size_                  = {},
                                           BufferUsageFlags  usage_                 = {},
                                           SharingMode       sharingMode_           = SharingMode::eExclusive,
                                           uint32_t          queueFamilyIndexCount_ = {},
                                           uint32_t const *  pQueueFamilyIndices_   = {},
                                           void const *      pNext_                 = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , size{ size_ }
      , usage{ usage_ }
      , sharingMode{ sharingMode_ }
      , queueFamilyIndexCount{ queueFamilyIndexCount_ }
      , pQueueFamilyIndices{ pQueueFamilyIndices_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferCreateInfo( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : BufferCreateInfo( *reinterpret_cast<BufferCreateInfo const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BufferCreateInfo( BufferCreateFlags                               flags_,
                      DeviceSize                                      size_,
                      BufferUsageFlags                                usage_,
                      SharingMode                                     sharingMode_,
                      ArrayProxyNoTemporaries<uint32_t const> const & queueFamilyIndices_,
                      void const *                                    pNext_ = nullptr )
      : pNext( pNext_ )
      , flags( flags_ )
      , size( size_ )
      , usage( usage_ )
      , sharingMode( sharingMode_ )
      , queueFamilyIndexCount( static_cast<uint32_t>( queueFamilyIndices_.size() ) )
      , pQueueFamilyIndices( queueFamilyIndices_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    BufferCreateInfo & operator=( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferCreateInfo & operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setFlags( BufferCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setFlags( BufferCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setUsage( BufferUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT
    {
      usage = usage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setUsage( BufferUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT
    {
      usage = usage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setSharingMode( SharingMode sharingMode_ ) & VULKAN_HPP_NOEXCEPT
    {
      sharingMode = sharingMode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setSharingMode( SharingMode sharingMode_ ) && VULKAN_HPP_NOEXCEPT
    {
      sharingMode = sharingMode_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      queueFamilyIndexCount = queueFamilyIndexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      queueFamilyIndexCount = queueFamilyIndexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setPQueueFamilyIndices( uint32_t const * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT
    {
      pQueueFamilyIndices = pQueueFamilyIndices_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setPQueueFamilyIndices( uint32_t const * pQueueFamilyIndices_ ) && VULKAN_HPP_NOEXCEPT
    {
      pQueueFamilyIndices = pQueueFamilyIndices_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    BufferCreateInfo & setQueueFamilyIndices( ArrayProxyNoTemporaries<uint32_t const> const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT
    {
      queueFamilyIndexCount = static_cast<uint32_t>( queueFamilyIndices_.size() );
      pQueueFamilyIndices   = queueFamilyIndices_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCreateInfo const *>( this );
    }

    operator VkBufferCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCreateInfo *>( this );
    }

    operator VkBufferCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCreateInfo const *>( this );
    }

    operator VkBufferCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               BufferCreateFlags const &,
               DeviceSize const &,
               BufferUsageFlags const &,
               SharingMode const &,
               uint32_t const &,
               uint32_t const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferCreateInfo const & ) const = default;
#else
    bool operator==( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( size == rhs.size ) && ( usage == rhs.usage ) &&
             ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
#  endif
    }

    bool operator!=( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType     sType                 = StructureType::eBufferCreateInfo;
    void const *      pNext                 = {};
    BufferCreateFlags flags                 = {};
    DeviceSize        size                  = {};
    BufferUsageFlags  usage                 = {};
    SharingMode       sharingMode           = SharingMode::eExclusive;
    uint32_t          queueFamilyIndexCount = {};
    uint32_t const *  pQueueFamilyIndices   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferCreateInfo>
  {
    using Type = BufferCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferCreateInfo>
  {
    using Type = BufferCreateInfo;
  };

#if defined( VK_USE_PLATFORM_FUCHSIA )
  // wrapper struct for struct VkBufferConstraintsInfoFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferConstraintsInfoFUCHSIA.html
  struct BufferConstraintsInfoFUCHSIA
  {
    using NativeType = VkBufferConstraintsInfoFUCHSIA;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferConstraintsInfoFUCHSIA;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferConstraintsInfoFUCHSIA( BufferCreateInfo                       createInfo_                  = {},
                                                       FormatFeatureFlags                     requiredFormatFeatures_      = {},
                                                       BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints_ = {},
                                                       void const *                           pNext_                       = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , createInfo{ createInfo_ }
      , requiredFormatFeatures{ requiredFormatFeatures_ }
      , bufferCollectionConstraints{ bufferCollectionConstraints_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferConstraintsInfoFUCHSIA( BufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferConstraintsInfoFUCHSIA( VkBufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferConstraintsInfoFUCHSIA( *reinterpret_cast<BufferConstraintsInfoFUCHSIA const *>( &rhs ) )
    {
    }

    BufferConstraintsInfoFUCHSIA & operator=( BufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferConstraintsInfoFUCHSIA & operator=( VkBufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferConstraintsInfoFUCHSIA const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & setCreateInfo( BufferCreateInfo const & createInfo_ ) & VULKAN_HPP_NOEXCEPT
    {
      createInfo = createInfo_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && setCreateInfo( BufferCreateInfo const & createInfo_ ) && VULKAN_HPP_NOEXCEPT
    {
      createInfo = createInfo_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) & VULKAN_HPP_NOEXCEPT
    {
      requiredFormatFeatures = requiredFormatFeatures_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) && VULKAN_HPP_NOEXCEPT
    {
      requiredFormatFeatures = requiredFormatFeatures_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA &
      setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      bufferCollectionConstraints = bufferCollectionConstraints_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA &&
      setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      bufferCollectionConstraints = bufferCollectionConstraints_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferConstraintsInfoFUCHSIA const *>( this );
    }

    operator VkBufferConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferConstraintsInfoFUCHSIA *>( this );
    }

    operator VkBufferConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferConstraintsInfoFUCHSIA const *>( this );
    }

    operator VkBufferConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferConstraintsInfoFUCHSIA *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::
      tuple<StructureType const &, void const * const &, BufferCreateInfo const &, FormatFeatureFlags const &, BufferCollectionConstraintsInfoFUCHSIA const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferConstraintsInfoFUCHSIA const & ) const = default;
#  else
    bool operator==( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) && ( requiredFormatFeatures == rhs.requiredFormatFeatures ) &&
             ( bufferCollectionConstraints == rhs.bufferCollectionConstraints );
#    endif
    }

    bool operator!=( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType                          sType                       = StructureType::eBufferConstraintsInfoFUCHSIA;
    void const *                           pNext                       = {};
    BufferCreateInfo                       createInfo                  = {};
    FormatFeatureFlags                     requiredFormatFeatures      = {};
    BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferConstraintsInfoFUCHSIA>
  {
    using Type = BufferConstraintsInfoFUCHSIA;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eBufferConstraintsInfoFUCHSIA>
  {
    using Type = BufferConstraintsInfoFUCHSIA;
  };
#endif /*VK_USE_PLATFORM_FUCHSIA*/

  // wrapper struct for struct VkBufferCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCopy.html
  struct BufferCopy
  {
    using NativeType = VkBufferCopy;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferCopy( DeviceSize srcOffset_ = {}, DeviceSize dstOffset_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
      : srcOffset{ srcOffset_ }
      , dstOffset{ dstOffset_ }
      , size{ size_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferCopy( BufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferCopy( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT : BufferCopy( *reinterpret_cast<BufferCopy const *>( &rhs ) ) {}

    BufferCopy & operator=( BufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferCopy & operator=( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferCopy const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferCopy & setSrcOffset( DeviceSize srcOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcOffset = srcOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy && setSrcOffset( DeviceSize srcOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcOffset = srcOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy & setDstOffset( DeviceSize dstOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstOffset = dstOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy && setDstOffset( DeviceSize dstOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstOffset = dstOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCopy const *>( this );
    }

    operator VkBufferCopy &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCopy *>( this );
    }

    operator VkBufferCopy const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCopy const *>( this );
    }

    operator VkBufferCopy *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCopy *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceSize const &, DeviceSize const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( srcOffset, dstOffset, size );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferCopy const & ) const = default;
#else
    bool operator==( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size );
#  endif
    }

    bool operator!=( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceSize srcOffset = {};
    DeviceSize dstOffset = {};
    DeviceSize size      = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferCopy>
  {
    using Type = BufferCopy;
  };
#endif

  // wrapper struct for struct VkBufferCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCopy2.html
  struct BufferCopy2
  {
    using NativeType = VkBufferCopy2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferCopy2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      BufferCopy2( DeviceSize srcOffset_ = {}, DeviceSize dstOffset_ = {}, DeviceSize size_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcOffset{ srcOffset_ }
      , dstOffset{ dstOffset_ }
      , size{ size_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferCopy2( BufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferCopy2( VkBufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT : BufferCopy2( *reinterpret_cast<BufferCopy2 const *>( &rhs ) ) {}

    BufferCopy2 & operator=( BufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferCopy2 & operator=( VkBufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferCopy2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setSrcOffset( DeviceSize srcOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcOffset = srcOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setSrcOffset( DeviceSize srcOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcOffset = srcOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setDstOffset( DeviceSize dstOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstOffset = dstOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setDstOffset( DeviceSize dstOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstOffset = dstOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferCopy2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCopy2 const *>( this );
    }

    operator VkBufferCopy2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferCopy2 *>( this );
    }

    operator VkBufferCopy2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCopy2 const *>( this );
    }

    operator VkBufferCopy2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferCopy2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceSize const &, DeviceSize const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcOffset, dstOffset, size );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferCopy2 const & ) const = default;
#else
    bool operator==( BufferCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size );
#  endif
    }

    bool operator!=( BufferCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType     = StructureType::eBufferCopy2;
    void const *  pNext     = {};
    DeviceSize    srcOffset = {};
    DeviceSize    dstOffset = {};
    DeviceSize    size      = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferCopy2>
  {
    using Type = BufferCopy2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferCopy2>
  {
    using Type = BufferCopy2;
  };

  using BufferCopy2KHR = BufferCopy2;

  // wrapper struct for struct VkBufferDeviceAddressCreateInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferDeviceAddressCreateInfoEXT.html
  struct BufferDeviceAddressCreateInfoEXT
  {
    using NativeType = VkBufferDeviceAddressCreateInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferDeviceAddressCreateInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( DeviceAddress deviceAddress_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , deviceAddress{ deviceAddress_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferDeviceAddressCreateInfoEXT( *reinterpret_cast<BufferDeviceAddressCreateInfoEXT const *>( &rhs ) )
    {
    }

    BufferDeviceAddressCreateInfoEXT & operator=( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferDeviceAddressCreateInfoEXT & operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferDeviceAddressCreateInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT const *>( this );
    }

    operator VkBufferDeviceAddressCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT *>( this );
    }

    operator VkBufferDeviceAddressCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT const *>( this );
    }

    operator VkBufferDeviceAddressCreateInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceAddress const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, deviceAddress );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferDeviceAddressCreateInfoEXT const & ) const = default;
#else
    bool operator==( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress );
#  endif
    }

    bool operator!=( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType         = StructureType::eBufferDeviceAddressCreateInfoEXT;
    void const *  pNext         = {};
    DeviceAddress deviceAddress = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferDeviceAddressCreateInfoEXT>
  {
    using Type = BufferDeviceAddressCreateInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferDeviceAddressCreateInfoEXT>
  {
    using Type = BufferDeviceAddressCreateInfoEXT;
  };

  // wrapper struct for struct VkBufferDeviceAddressInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferDeviceAddressInfo.html
  struct BufferDeviceAddressInfo
  {
    using NativeType = VkBufferDeviceAddressInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferDeviceAddressInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( Buffer buffer_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , buffer{ buffer_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferDeviceAddressInfo( VkBufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferDeviceAddressInfo( *reinterpret_cast<BufferDeviceAddressInfo const *>( &rhs ) )
    {
    }

    BufferDeviceAddressInfo & operator=( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferDeviceAddressInfo & operator=( VkBufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferDeviceAddressInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferDeviceAddressInfo const *>( this );
    }

    operator VkBufferDeviceAddressInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferDeviceAddressInfo *>( this );
    }

    operator VkBufferDeviceAddressInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferDeviceAddressInfo const *>( this );
    }

    operator VkBufferDeviceAddressInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferDeviceAddressInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Buffer const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, buffer );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferDeviceAddressInfo const & ) const = default;
#else
    bool operator==( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
#  endif
    }

    bool operator!=( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType  = StructureType::eBufferDeviceAddressInfo;
    void const *  pNext  = {};
    Buffer        buffer = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferDeviceAddressInfo>
  {
    using Type = BufferDeviceAddressInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferDeviceAddressInfo>
  {
    using Type = BufferDeviceAddressInfo;
  };

  using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
  using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;

  // wrapper struct for struct VkBufferImageCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferImageCopy.html
  struct BufferImageCopy
  {
    using NativeType = VkBufferImageCopy;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferImageCopy( DeviceSize             bufferOffset_      = {},
                                          uint32_t               bufferRowLength_   = {},
                                          uint32_t               bufferImageHeight_ = {},
                                          ImageSubresourceLayers imageSubresource_  = {},
                                          Offset3D               imageOffset_       = {},
                                          Extent3D               imageExtent_       = {} ) VULKAN_HPP_NOEXCEPT
      : bufferOffset{ bufferOffset_ }
      , bufferRowLength{ bufferRowLength_ }
      , bufferImageHeight{ bufferImageHeight_ }
      , imageSubresource{ imageSubresource_ }
      , imageOffset{ imageOffset_ }
      , imageExtent{ imageExtent_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferImageCopy( BufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferImageCopy( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT : BufferImageCopy( *reinterpret_cast<BufferImageCopy const *>( &rhs ) ) {}

    BufferImageCopy & operator=( BufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferImageCopy & operator=( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferImageCopy const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setBufferOffset( DeviceSize bufferOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferOffset = bufferOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setBufferOffset( DeviceSize bufferOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferOffset = bufferOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setBufferRowLength( uint32_t bufferRowLength_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferRowLength = bufferRowLength_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setBufferRowLength( uint32_t bufferRowLength_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferRowLength = bufferRowLength_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setBufferImageHeight( uint32_t bufferImageHeight_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferImageHeight = bufferImageHeight_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setBufferImageHeight( uint32_t bufferImageHeight_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferImageHeight = bufferImageHeight_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferImageCopy const *>( this );
    }

    operator VkBufferImageCopy &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferImageCopy *>( this );
    }

    operator VkBufferImageCopy const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferImageCopy const *>( this );
    }

    operator VkBufferImageCopy *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferImageCopy *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceSize const &, uint32_t const &, uint32_t const &, ImageSubresourceLayers const &, Offset3D const &, Extent3D const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferImageCopy const & ) const = default;
#else
    bool operator==( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) &&
             ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent );
#  endif
    }

    bool operator!=( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceSize             bufferOffset      = {};
    uint32_t               bufferRowLength   = {};
    uint32_t               bufferImageHeight = {};
    ImageSubresourceLayers imageSubresource  = {};
    Offset3D               imageOffset       = {};
    Extent3D               imageExtent       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferImageCopy>
  {
    using Type = BufferImageCopy;
  };
#endif

  // wrapper struct for struct VkBufferImageCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferImageCopy2.html
  struct BufferImageCopy2
  {
    using NativeType = VkBufferImageCopy2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferImageCopy2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferImageCopy2( DeviceSize             bufferOffset_      = {},
                                           uint32_t               bufferRowLength_   = {},
                                           uint32_t               bufferImageHeight_ = {},
                                           ImageSubresourceLayers imageSubresource_  = {},
                                           Offset3D               imageOffset_       = {},
                                           Extent3D               imageExtent_       = {},
                                           void const *           pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , bufferOffset{ bufferOffset_ }
      , bufferRowLength{ bufferRowLength_ }
      , bufferImageHeight{ bufferImageHeight_ }
      , imageSubresource{ imageSubresource_ }
      , imageOffset{ imageOffset_ }
      , imageExtent{ imageExtent_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferImageCopy2( BufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferImageCopy2( VkBufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT : BufferImageCopy2( *reinterpret_cast<BufferImageCopy2 const *>( &rhs ) ) {}

    BufferImageCopy2 & operator=( BufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferImageCopy2 & operator=( VkBufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferImageCopy2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setBufferOffset( DeviceSize bufferOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferOffset = bufferOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setBufferOffset( DeviceSize bufferOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferOffset = bufferOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setBufferRowLength( uint32_t bufferRowLength_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferRowLength = bufferRowLength_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setBufferRowLength( uint32_t bufferRowLength_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferRowLength = bufferRowLength_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setBufferImageHeight( uint32_t bufferImageHeight_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferImageHeight = bufferImageHeight_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setBufferImageHeight( uint32_t bufferImageHeight_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferImageHeight = bufferImageHeight_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferImageCopy2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferImageCopy2 const *>( this );
    }

    operator VkBufferImageCopy2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferImageCopy2 *>( this );
    }

    operator VkBufferImageCopy2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferImageCopy2 const *>( this );
    }

    operator VkBufferImageCopy2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferImageCopy2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DeviceSize const &,
               uint32_t const &,
               uint32_t const &,
               ImageSubresourceLayers const &,
               Offset3D const &,
               Extent3D const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferImageCopy2 const & ) const = default;
#else
    bool operator==( BufferImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) &&
             ( bufferImageHeight == rhs.bufferImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) &&
             ( imageExtent == rhs.imageExtent );
#  endif
    }

    bool operator!=( BufferImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType             = StructureType::eBufferImageCopy2;
    void const *           pNext             = {};
    DeviceSize             bufferOffset      = {};
    uint32_t               bufferRowLength   = {};
    uint32_t               bufferImageHeight = {};
    ImageSubresourceLayers imageSubresource  = {};
    Offset3D               imageOffset       = {};
    Extent3D               imageExtent       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferImageCopy2>
  {
    using Type = BufferImageCopy2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferImageCopy2>
  {
    using Type = BufferImageCopy2;
  };

  using BufferImageCopy2KHR = BufferImageCopy2;

  // wrapper struct for struct VkBufferMemoryBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryBarrier.html
  struct BufferMemoryBarrier
  {
    using NativeType = VkBufferMemoryBarrier;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferMemoryBarrier;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( AccessFlags  srcAccessMask_       = {},
                                              AccessFlags  dstAccessMask_       = {},
                                              uint32_t     srcQueueFamilyIndex_ = {},
                                              uint32_t     dstQueueFamilyIndex_ = {},
                                              Buffer       buffer_              = {},
                                              DeviceSize   offset_              = {},
                                              DeviceSize   size_                = {},
                                              void const * pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcAccessMask{ srcAccessMask_ }
      , dstAccessMask{ dstAccessMask_ }
      , srcQueueFamilyIndex{ srcQueueFamilyIndex_ }
      , dstQueueFamilyIndex{ dstQueueFamilyIndex_ }
      , buffer{ buffer_ }
      , offset{ offset_ }
      , size{ size_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT : BufferMemoryBarrier( *reinterpret_cast<BufferMemoryBarrier const *>( &rhs ) )
    {
    }

    BufferMemoryBarrier & operator=( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferMemoryBarrier & operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferMemoryBarrier const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcAccessMask = srcAccessMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcAccessMask = srcAccessMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstAccessMask = dstAccessMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstAccessMask = dstAccessMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcQueueFamilyIndex = srcQueueFamilyIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcQueueFamilyIndex = srcQueueFamilyIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstQueueFamilyIndex = dstQueueFamilyIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstQueueFamilyIndex = dstQueueFamilyIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferMemoryBarrier const *>( this );
    }

    operator VkBufferMemoryBarrier &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferMemoryBarrier *>( this );
    }

    operator VkBufferMemoryBarrier const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferMemoryBarrier const *>( this );
    }

    operator VkBufferMemoryBarrier *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferMemoryBarrier *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AccessFlags const &,
               AccessFlags const &,
               uint32_t const &,
               uint32_t const &,
               Buffer const &,
               DeviceSize const &,
               DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferMemoryBarrier const & ) const = default;
#else
    bool operator==( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) &&
             ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) &&
             ( offset == rhs.offset ) && ( size == rhs.size );
#  endif
    }

    bool operator!=( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType               = StructureType::eBufferMemoryBarrier;
    void const *  pNext               = {};
    AccessFlags   srcAccessMask       = {};
    AccessFlags   dstAccessMask       = {};
    uint32_t      srcQueueFamilyIndex = {};
    uint32_t      dstQueueFamilyIndex = {};
    Buffer        buffer              = {};
    DeviceSize    offset              = {};
    DeviceSize    size                = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferMemoryBarrier>
  {
    using Type = BufferMemoryBarrier;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferMemoryBarrier>
  {
    using Type = BufferMemoryBarrier;
  };

  // wrapper struct for struct VkBufferMemoryBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryBarrier2.html
  struct BufferMemoryBarrier2
  {
    using NativeType = VkBufferMemoryBarrier2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferMemoryBarrier2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferMemoryBarrier2( PipelineStageFlags2 srcStageMask_        = {},
                                               AccessFlags2        srcAccessMask_       = {},
                                               PipelineStageFlags2 dstStageMask_        = {},
                                               AccessFlags2        dstAccessMask_       = {},
                                               uint32_t            srcQueueFamilyIndex_ = {},
                                               uint32_t            dstQueueFamilyIndex_ = {},
                                               Buffer              buffer_              = {},
                                               DeviceSize          offset_              = {},
                                               DeviceSize          size_                = {},
                                               void const *        pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcStageMask{ srcStageMask_ }
      , srcAccessMask{ srcAccessMask_ }
      , dstStageMask{ dstStageMask_ }
      , dstAccessMask{ dstAccessMask_ }
      , srcQueueFamilyIndex{ srcQueueFamilyIndex_ }
      , dstQueueFamilyIndex{ dstQueueFamilyIndex_ }
      , buffer{ buffer_ }
      , offset{ offset_ }
      , size{ size_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferMemoryBarrier2( BufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferMemoryBarrier2( VkBufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferMemoryBarrier2( *reinterpret_cast<BufferMemoryBarrier2 const *>( &rhs ) )
    {
    }

    BufferMemoryBarrier2 & operator=( BufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferMemoryBarrier2 & operator=( VkBufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferMemoryBarrier2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcStageMask = srcStageMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcStageMask = srcStageMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcAccessMask = srcAccessMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcAccessMask = srcAccessMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstStageMask = dstStageMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstStageMask = dstStageMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstAccessMask = dstAccessMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstAccessMask = dstAccessMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcQueueFamilyIndex = srcQueueFamilyIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcQueueFamilyIndex = srcQueueFamilyIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstQueueFamilyIndex = dstQueueFamilyIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstQueueFamilyIndex = dstQueueFamilyIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferMemoryBarrier2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferMemoryBarrier2 const *>( this );
    }

    operator VkBufferMemoryBarrier2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferMemoryBarrier2 *>( this );
    }

    operator VkBufferMemoryBarrier2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferMemoryBarrier2 const *>( this );
    }

    operator VkBufferMemoryBarrier2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferMemoryBarrier2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               PipelineStageFlags2 const &,
               AccessFlags2 const &,
               PipelineStageFlags2 const &,
               AccessFlags2 const &,
               uint32_t const &,
               uint32_t const &,
               Buffer const &,
               DeviceSize const &,
               DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferMemoryBarrier2 const & ) const = default;
#else
    bool operator==( BufferMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) &&
             ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
             ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( size == rhs.size );
#  endif
    }

    bool operator!=( BufferMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType       sType               = StructureType::eBufferMemoryBarrier2;
    void const *        pNext               = {};
    PipelineStageFlags2 srcStageMask        = {};
    AccessFlags2        srcAccessMask       = {};
    PipelineStageFlags2 dstStageMask        = {};
    AccessFlags2        dstAccessMask       = {};
    uint32_t            srcQueueFamilyIndex = {};
    uint32_t            dstQueueFamilyIndex = {};
    Buffer              buffer              = {};
    DeviceSize          offset              = {};
    DeviceSize          size                = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferMemoryBarrier2>
  {
    using Type = BufferMemoryBarrier2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferMemoryBarrier2>
  {
    using Type = BufferMemoryBarrier2;
  };

  using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;

  // wrapper struct for struct VkBufferMemoryRequirementsInfo2, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryRequirementsInfo2.html
  struct BufferMemoryRequirementsInfo2
  {
    using NativeType = VkBufferMemoryRequirementsInfo2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferMemoryRequirementsInfo2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( Buffer buffer_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , buffer{ buffer_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferMemoryRequirementsInfo2( *reinterpret_cast<BufferMemoryRequirementsInfo2 const *>( &rhs ) )
    {
    }

    BufferMemoryRequirementsInfo2 & operator=( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferMemoryRequirementsInfo2 & operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferMemoryRequirementsInfo2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferMemoryRequirementsInfo2 const *>( this );
    }

    operator VkBufferMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferMemoryRequirementsInfo2 *>( this );
    }

    operator VkBufferMemoryRequirementsInfo2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferMemoryRequirementsInfo2 const *>( this );
    }

    operator VkBufferMemoryRequirementsInfo2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferMemoryRequirementsInfo2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Buffer const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, buffer );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferMemoryRequirementsInfo2 const & ) const = default;
#else
    bool operator==( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
#  endif
    }

    bool operator!=( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType  = StructureType::eBufferMemoryRequirementsInfo2;
    void const *  pNext  = {};
    Buffer        buffer = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferMemoryRequirementsInfo2>
  {
    using Type = BufferMemoryRequirementsInfo2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferMemoryRequirementsInfo2>
  {
    using Type = BufferMemoryRequirementsInfo2;
  };

  using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;

  // wrapper struct for struct VkBufferOpaqueCaptureAddressCreateInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html
  struct BufferOpaqueCaptureAddressCreateInfo
  {
    using NativeType = VkBufferOpaqueCaptureAddressCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferOpaqueCaptureAddressCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( uint64_t opaqueCaptureAddress_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , opaqueCaptureAddress{ opaqueCaptureAddress_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferOpaqueCaptureAddressCreateInfo( VkBufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferOpaqueCaptureAddressCreateInfo( *reinterpret_cast<BufferOpaqueCaptureAddressCreateInfo const *>( &rhs ) )
    {
    }

    BufferOpaqueCaptureAddressCreateInfo & operator=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferOpaqueCaptureAddressCreateInfo & operator=( VkBufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferOpaqueCaptureAddressCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo & setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      opaqueCaptureAddress = opaqueCaptureAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo && setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      opaqueCaptureAddress = opaqueCaptureAddress_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo const *>( this );
    }

    operator VkBufferOpaqueCaptureAddressCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo *>( this );
    }

    operator VkBufferOpaqueCaptureAddressCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo const *>( this );
    }

    operator VkBufferOpaqueCaptureAddressCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint64_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, opaqueCaptureAddress );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const & ) const = default;
#else
    bool operator==( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress );
#  endif
    }

    bool operator!=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                = StructureType::eBufferOpaqueCaptureAddressCreateInfo;
    void const *  pNext                = {};
    uint64_t      opaqueCaptureAddress = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferOpaqueCaptureAddressCreateInfo>
  {
    using Type = BufferOpaqueCaptureAddressCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferOpaqueCaptureAddressCreateInfo>
  {
    using Type = BufferOpaqueCaptureAddressCreateInfo;
  };

  using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;

  // wrapper struct for struct VkBufferUsageFlags2CreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlags2CreateInfo.html
  struct BufferUsageFlags2CreateInfo
  {
    using NativeType = VkBufferUsageFlags2CreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferUsageFlags2CreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferUsageFlags2CreateInfo( BufferUsageFlags2 usage_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , usage{ usage_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferUsageFlags2CreateInfo( BufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferUsageFlags2CreateInfo( VkBufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferUsageFlags2CreateInfo( *reinterpret_cast<BufferUsageFlags2CreateInfo const *>( &rhs ) )
    {
    }

    BufferUsageFlags2CreateInfo & operator=( BufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferUsageFlags2CreateInfo & operator=( VkBufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferUsageFlags2CreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo & setUsage( BufferUsageFlags2 usage_ ) & VULKAN_HPP_NOEXCEPT
    {
      usage = usage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo && setUsage( BufferUsageFlags2 usage_ ) && VULKAN_HPP_NOEXCEPT
    {
      usage = usage_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferUsageFlags2CreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferUsageFlags2CreateInfo const *>( this );
    }

    operator VkBufferUsageFlags2CreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferUsageFlags2CreateInfo *>( this );
    }

    operator VkBufferUsageFlags2CreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferUsageFlags2CreateInfo const *>( this );
    }

    operator VkBufferUsageFlags2CreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferUsageFlags2CreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, BufferUsageFlags2 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, usage );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferUsageFlags2CreateInfo const & ) const = default;
#else
    bool operator==( BufferUsageFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage );
#  endif
    }

    bool operator!=( BufferUsageFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType     sType = StructureType::eBufferUsageFlags2CreateInfo;
    void const *      pNext = {};
    BufferUsageFlags2 usage = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferUsageFlags2CreateInfo>
  {
    using Type = BufferUsageFlags2CreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferUsageFlags2CreateInfo>
  {
    using Type = BufferUsageFlags2CreateInfo;
  };

  using BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo;

  // wrapper struct for struct VkBufferViewCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferViewCreateInfo.html
  struct BufferViewCreateInfo
  {
    using NativeType = VkBufferViewCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBufferViewCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( BufferViewCreateFlags flags_  = {},
                                               Buffer                buffer_ = {},
                                               Format                format_ = Format::eUndefined,
                                               DeviceSize            offset_ = {},
                                               DeviceSize            range_  = {},
                                               void const *          pNext_  = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , buffer{ buffer_ }
      , format{ format_ }
      , offset{ offset_ }
      , range{ range_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : BufferViewCreateInfo( *reinterpret_cast<BufferViewCreateInfo const *>( &rhs ) )
    {
    }

    BufferViewCreateInfo & operator=( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BufferViewCreateInfo & operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BufferViewCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setFlags( BufferViewCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setFlags( BufferViewCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setRange( DeviceSize range_ ) & VULKAN_HPP_NOEXCEPT
    {
      range = range_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setRange( DeviceSize range_ ) && VULKAN_HPP_NOEXCEPT
    {
      range = range_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferViewCreateInfo const *>( this );
    }

    operator VkBufferViewCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBufferViewCreateInfo *>( this );
    }

    operator VkBufferViewCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferViewCreateInfo const *>( this );
    }

    operator VkBufferViewCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBufferViewCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::
      tuple<StructureType const &, void const * const &, BufferViewCreateFlags const &, Buffer const &, Format const &, DeviceSize const &, DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, buffer, format, offset, range );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BufferViewCreateInfo const & ) const = default;
#else
    bool operator==( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) && ( format == rhs.format ) &&
             ( offset == rhs.offset ) && ( range == rhs.range );
#  endif
    }

    bool operator!=( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType         sType  = StructureType::eBufferViewCreateInfo;
    void const *          pNext  = {};
    BufferViewCreateFlags flags  = {};
    Buffer                buffer = {};
    Format                format = Format::eUndefined;
    DeviceSize            offset = {};
    DeviceSize            range  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBufferViewCreateInfo>
  {
    using Type = BufferViewCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBufferViewCreateInfo>
  {
    using Type = BufferViewCreateInfo;
  };

  // wrapper struct for struct VkStridedDeviceAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressNV.html
  struct StridedDeviceAddressNV
  {
    using NativeType = VkStridedDeviceAddressNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR StridedDeviceAddressNV( DeviceAddress startAddress_ = {}, DeviceSize strideInBytes_ = {} ) VULKAN_HPP_NOEXCEPT
      : startAddress{ startAddress_ }
      , strideInBytes{ strideInBytes_ }
    {
    }

    VULKAN_HPP_CONSTEXPR StridedDeviceAddressNV( StridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    StridedDeviceAddressNV( VkStridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : StridedDeviceAddressNV( *reinterpret_cast<StridedDeviceAddressNV const *>( &rhs ) )
    {
    }

    StridedDeviceAddressNV & operator=( StridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    StridedDeviceAddressNV & operator=( VkStridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<StridedDeviceAddressNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV & setStartAddress( DeviceAddress startAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      startAddress = startAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV && setStartAddress( DeviceAddress startAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      startAddress = startAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV & setStrideInBytes( DeviceSize strideInBytes_ ) & VULKAN_HPP_NOEXCEPT
    {
      strideInBytes = strideInBytes_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV && setStrideInBytes( DeviceSize strideInBytes_ ) && VULKAN_HPP_NOEXCEPT
    {
      strideInBytes = strideInBytes_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkStridedDeviceAddressNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkStridedDeviceAddressNV const *>( this );
    }

    operator VkStridedDeviceAddressNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkStridedDeviceAddressNV *>( this );
    }

    operator VkStridedDeviceAddressNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkStridedDeviceAddressNV const *>( this );
    }

    operator VkStridedDeviceAddressNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkStridedDeviceAddressNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( startAddress, strideInBytes );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( StridedDeviceAddressNV const & ) const = default;
#else
    bool operator==( StridedDeviceAddressNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( startAddress == rhs.startAddress ) && ( strideInBytes == rhs.strideInBytes );
#  endif
    }

    bool operator!=( StridedDeviceAddressNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress startAddress  = {};
    DeviceSize    strideInBytes = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkStridedDeviceAddressNV>
  {
    using Type = StridedDeviceAddressNV;
  };
#endif

  // wrapper struct for struct VkBuildPartitionedAccelerationStructureIndirectCommandNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildPartitionedAccelerationStructureIndirectCommandNV.html
  struct BuildPartitionedAccelerationStructureIndirectCommandNV
  {
    using NativeType = VkBuildPartitionedAccelerationStructureIndirectCommandNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureIndirectCommandNV(
      PartitionedAccelerationStructureOpTypeNV opType_   = PartitionedAccelerationStructureOpTypeNV::eWriteInstance,
      uint32_t                                 argCount_ = {},
      StridedDeviceAddressNV                   argData_  = {} ) VULKAN_HPP_NOEXCEPT
      : opType{ opType_ }
      , argCount{ argCount_ }
      , argData{ argData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureIndirectCommandNV( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs )
      VULKAN_HPP_NOEXCEPT = default;

    BuildPartitionedAccelerationStructureIndirectCommandNV( VkBuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : BuildPartitionedAccelerationStructureIndirectCommandNV( *reinterpret_cast<BuildPartitionedAccelerationStructureIndirectCommandNV const *>( &rhs ) )
    {
    }

    BuildPartitionedAccelerationStructureIndirectCommandNV &
      operator=( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BuildPartitionedAccelerationStructureIndirectCommandNV &
      operator=( VkBuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BuildPartitionedAccelerationStructureIndirectCommandNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV & setOpType( PartitionedAccelerationStructureOpTypeNV opType_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      opType = opType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV && setOpType( PartitionedAccelerationStructureOpTypeNV opType_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opType = opType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV & setArgCount( uint32_t argCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      argCount = argCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV && setArgCount( uint32_t argCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      argCount = argCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV & setArgData( StridedDeviceAddressNV const & argData_ ) & VULKAN_HPP_NOEXCEPT
    {
      argData = argData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV && setArgData( StridedDeviceAddressNV const & argData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      argData = argData_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBuildPartitionedAccelerationStructureIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBuildPartitionedAccelerationStructureIndirectCommandNV const *>( this );
    }

    operator VkBuildPartitionedAccelerationStructureIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBuildPartitionedAccelerationStructureIndirectCommandNV *>( this );
    }

    operator VkBuildPartitionedAccelerationStructureIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBuildPartitionedAccelerationStructureIndirectCommandNV const *>( this );
    }

    operator VkBuildPartitionedAccelerationStructureIndirectCommandNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBuildPartitionedAccelerationStructureIndirectCommandNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<PartitionedAccelerationStructureOpTypeNV const &, uint32_t const &, StridedDeviceAddressNV const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( opType, argCount, argData );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BuildPartitionedAccelerationStructureIndirectCommandNV const & ) const = default;
#else
    bool operator==( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( opType == rhs.opType ) && ( argCount == rhs.argCount ) && ( argData == rhs.argData );
#  endif
    }

    bool operator!=( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    PartitionedAccelerationStructureOpTypeNV opType   = PartitionedAccelerationStructureOpTypeNV::eWriteInstance;
    uint32_t                                 argCount = {};
    StridedDeviceAddressNV                   argData  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBuildPartitionedAccelerationStructureIndirectCommandNV>
  {
    using Type = BuildPartitionedAccelerationStructureIndirectCommandNV;
  };
#endif

  // wrapper struct for struct VkPartitionedAccelerationStructureInstancesInputNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstancesInputNV.html
  struct PartitionedAccelerationStructureInstancesInputNV
  {
    using NativeType = VkPartitionedAccelerationStructureInstancesInputNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePartitionedAccelerationStructureInstancesInputNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR PartitionedAccelerationStructureInstancesInputNV( BuildAccelerationStructureFlagsKHR flags_                             = {},
                                                                           uint32_t                           instanceCount_                     = {},
                                                                           uint32_t                           maxInstancePerPartitionCount_      = {},
                                                                           uint32_t                           partitionCount_                    = {},
                                                                           uint32_t                           maxInstanceInGlobalPartitionCount_ = {},
                                                                           void *                             pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , instanceCount{ instanceCount_ }
      , maxInstancePerPartitionCount{ maxInstancePerPartitionCount_ }
      , partitionCount{ partitionCount_ }
      , maxInstanceInGlobalPartitionCount{ maxInstanceInGlobalPartitionCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      PartitionedAccelerationStructureInstancesInputNV( PartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    PartitionedAccelerationStructureInstancesInputNV( VkPartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : PartitionedAccelerationStructureInstancesInputNV( *reinterpret_cast<PartitionedAccelerationStructureInstancesInputNV const *>( &rhs ) )
    {
    }

    PartitionedAccelerationStructureInstancesInputNV & operator=( PartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    PartitionedAccelerationStructureInstancesInputNV & operator=( VkPartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<PartitionedAccelerationStructureInstancesInputNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      instanceCount = instanceCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      instanceCount = instanceCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setMaxInstancePerPartitionCount( uint32_t maxInstancePerPartitionCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxInstancePerPartitionCount = maxInstancePerPartitionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setMaxInstancePerPartitionCount( uint32_t maxInstancePerPartitionCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxInstancePerPartitionCount = maxInstancePerPartitionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setPartitionCount( uint32_t partitionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      partitionCount = partitionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setPartitionCount( uint32_t partitionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      partitionCount = partitionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV &
      setMaxInstanceInGlobalPartitionCount( uint32_t maxInstanceInGlobalPartitionCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxInstanceInGlobalPartitionCount = maxInstanceInGlobalPartitionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV &&
      setMaxInstanceInGlobalPartitionCount( uint32_t maxInstanceInGlobalPartitionCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxInstanceInGlobalPartitionCount = maxInstanceInGlobalPartitionCount_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkPartitionedAccelerationStructureInstancesInputNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkPartitionedAccelerationStructureInstancesInputNV const *>( this );
    }

    operator VkPartitionedAccelerationStructureInstancesInputNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkPartitionedAccelerationStructureInstancesInputNV *>( this );
    }

    operator VkPartitionedAccelerationStructureInstancesInputNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkPartitionedAccelerationStructureInstancesInputNV const *>( this );
    }

    operator VkPartitionedAccelerationStructureInstancesInputNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkPartitionedAccelerationStructureInstancesInputNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               BuildAccelerationStructureFlagsKHR const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, instanceCount, maxInstancePerPartitionCount, partitionCount, maxInstanceInGlobalPartitionCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( PartitionedAccelerationStructureInstancesInputNV const & ) const = default;
#else
    bool operator==( PartitionedAccelerationStructureInstancesInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( instanceCount == rhs.instanceCount ) &&
             ( maxInstancePerPartitionCount == rhs.maxInstancePerPartitionCount ) && ( partitionCount == rhs.partitionCount ) &&
             ( maxInstanceInGlobalPartitionCount == rhs.maxInstanceInGlobalPartitionCount );
#  endif
    }

    bool operator!=( PartitionedAccelerationStructureInstancesInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                      sType                             = StructureType::ePartitionedAccelerationStructureInstancesInputNV;
    void *                             pNext                             = {};
    BuildAccelerationStructureFlagsKHR flags                             = {};
    uint32_t                           instanceCount                     = {};
    uint32_t                           maxInstancePerPartitionCount      = {};
    uint32_t                           partitionCount                    = {};
    uint32_t                           maxInstanceInGlobalPartitionCount = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkPartitionedAccelerationStructureInstancesInputNV>
  {
    using Type = PartitionedAccelerationStructureInstancesInputNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::ePartitionedAccelerationStructureInstancesInputNV>
  {
    using Type = PartitionedAccelerationStructureInstancesInputNV;
  };

  // wrapper struct for struct VkBuildPartitionedAccelerationStructureInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildPartitionedAccelerationStructureInfoNV.html
  struct BuildPartitionedAccelerationStructureInfoNV
  {
    using NativeType = VkBuildPartitionedAccelerationStructureInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eBuildPartitionedAccelerationStructureInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureInfoNV( PartitionedAccelerationStructureInstancesInputNV input_                        = {},
                                                                      DeviceAddress                                    srcAccelerationStructureData_ = {},
                                                                      DeviceAddress                                    dstAccelerationStructureData_ = {},
                                                                      DeviceAddress                                    scratchData_                  = {},
                                                                      DeviceAddress                                    srcInfos_                     = {},
                                                                      DeviceAddress                                    srcInfosCount_                = {},
                                                                      void *                                           pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , input{ input_ }
      , srcAccelerationStructureData{ srcAccelerationStructureData_ }
      , dstAccelerationStructureData{ dstAccelerationStructureData_ }
      , scratchData{ scratchData_ }
      , srcInfos{ srcInfos_ }
      , srcInfosCount{ srcInfosCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureInfoNV( BuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    BuildPartitionedAccelerationStructureInfoNV( VkBuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : BuildPartitionedAccelerationStructureInfoNV( *reinterpret_cast<BuildPartitionedAccelerationStructureInfoNV const *>( &rhs ) )
    {
    }

    BuildPartitionedAccelerationStructureInfoNV & operator=( BuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    BuildPartitionedAccelerationStructureInfoNV & operator=( VkBuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<BuildPartitionedAccelerationStructureInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setInput( PartitionedAccelerationStructureInstancesInputNV const & input_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      input = input_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setInput( PartitionedAccelerationStructureInstancesInputNV const & input_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      input = input_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setSrcAccelerationStructureData( DeviceAddress srcAccelerationStructureData_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      srcAccelerationStructureData = srcAccelerationStructureData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setSrcAccelerationStructureData( DeviceAddress srcAccelerationStructureData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      srcAccelerationStructureData = srcAccelerationStructureData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setDstAccelerationStructureData( DeviceAddress dstAccelerationStructureData_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      dstAccelerationStructureData = dstAccelerationStructureData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setDstAccelerationStructureData( DeviceAddress dstAccelerationStructureData_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      dstAccelerationStructureData = dstAccelerationStructureData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setScratchData( DeviceAddress scratchData_ ) & VULKAN_HPP_NOEXCEPT
    {
      scratchData = scratchData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setScratchData( DeviceAddress scratchData_ ) && VULKAN_HPP_NOEXCEPT
    {
      scratchData = scratchData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setSrcInfos( DeviceAddress srcInfos_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcInfos = srcInfos_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setSrcInfos( DeviceAddress srcInfos_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcInfos = srcInfos_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setSrcInfosCount( DeviceAddress srcInfosCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcInfosCount = srcInfosCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setSrcInfosCount( DeviceAddress srcInfosCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcInfosCount = srcInfosCount_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkBuildPartitionedAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBuildPartitionedAccelerationStructureInfoNV const *>( this );
    }

    operator VkBuildPartitionedAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkBuildPartitionedAccelerationStructureInfoNV *>( this );
    }

    operator VkBuildPartitionedAccelerationStructureInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBuildPartitionedAccelerationStructureInfoNV const *>( this );
    }

    operator VkBuildPartitionedAccelerationStructureInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkBuildPartitionedAccelerationStructureInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               PartitionedAccelerationStructureInstancesInputNV const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, input, srcAccelerationStructureData, dstAccelerationStructureData, scratchData, srcInfos, srcInfosCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( BuildPartitionedAccelerationStructureInfoNV const & ) const = default;
#else
    bool operator==( BuildPartitionedAccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( input == rhs.input ) &&
             ( srcAccelerationStructureData == rhs.srcAccelerationStructureData ) && ( dstAccelerationStructureData == rhs.dstAccelerationStructureData ) &&
             ( scratchData == rhs.scratchData ) && ( srcInfos == rhs.srcInfos ) && ( srcInfosCount == rhs.srcInfosCount );
#  endif
    }

    bool operator!=( BuildPartitionedAccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                                    sType                        = StructureType::eBuildPartitionedAccelerationStructureInfoNV;
    void *                                           pNext                        = {};
    PartitionedAccelerationStructureInstancesInputNV input                        = {};
    DeviceAddress                                    srcAccelerationStructureData = {};
    DeviceAddress                                    dstAccelerationStructureData = {};
    DeviceAddress                                    scratchData                  = {};
    DeviceAddress                                    srcInfos                     = {};
    DeviceAddress                                    srcInfosCount                = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkBuildPartitionedAccelerationStructureInfoNV>
  {
    using Type = BuildPartitionedAccelerationStructureInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eBuildPartitionedAccelerationStructureInfoNV>
  {
    using Type = BuildPartitionedAccelerationStructureInfoNV;
  };

  // wrapper struct for struct VkCalibratedTimestampInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCalibratedTimestampInfoKHR.html
  struct CalibratedTimestampInfoKHR
  {
    using NativeType = VkCalibratedTimestampInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCalibratedTimestampInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoKHR( TimeDomainKHR timeDomain_ = TimeDomainKHR::eDevice, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , timeDomain{ timeDomain_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoKHR( CalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CalibratedTimestampInfoKHR( VkCalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CalibratedTimestampInfoKHR( *reinterpret_cast<CalibratedTimestampInfoKHR const *>( &rhs ) )
    {
    }

    CalibratedTimestampInfoKHR & operator=( CalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CalibratedTimestampInfoKHR & operator=( VkCalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CalibratedTimestampInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR & setTimeDomain( TimeDomainKHR timeDomain_ ) & VULKAN_HPP_NOEXCEPT
    {
      timeDomain = timeDomain_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR && setTimeDomain( TimeDomainKHR timeDomain_ ) && VULKAN_HPP_NOEXCEPT
    {
      timeDomain = timeDomain_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCalibratedTimestampInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCalibratedTimestampInfoKHR const *>( this );
    }

    operator VkCalibratedTimestampInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCalibratedTimestampInfoKHR *>( this );
    }

    operator VkCalibratedTimestampInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCalibratedTimestampInfoKHR const *>( this );
    }

    operator VkCalibratedTimestampInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCalibratedTimestampInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, TimeDomainKHR const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, timeDomain );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CalibratedTimestampInfoKHR const & ) const = default;
#else
    bool operator==( CalibratedTimestampInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain );
#  endif
    }

    bool operator!=( CalibratedTimestampInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType      = StructureType::eCalibratedTimestampInfoKHR;
    void const *  pNext      = {};
    TimeDomainKHR timeDomain = TimeDomainKHR::eDevice;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCalibratedTimestampInfoKHR>
  {
    using Type = CalibratedTimestampInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCalibratedTimestampInfoKHR>
  {
    using Type = CalibratedTimestampInfoKHR;
  };

  using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;

  // wrapper struct for struct VkCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCheckpointData2NV.html
  struct CheckpointData2NV
  {
    using NativeType = VkCheckpointData2NV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCheckpointData2NV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CheckpointData2NV( PipelineStageFlags2 stage_ = {}, void * pCheckpointMarker_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , stage{ stage_ }
      , pCheckpointMarker{ pCheckpointMarker_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CheckpointData2NV( CheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CheckpointData2NV( VkCheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT : CheckpointData2NV( *reinterpret_cast<CheckpointData2NV const *>( &rhs ) ) {}

    CheckpointData2NV & operator=( CheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CheckpointData2NV & operator=( VkCheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CheckpointData2NV const *>( &rhs );
      return *this;
    }

    operator VkCheckpointData2NV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCheckpointData2NV const *>( this );
    }

    operator VkCheckpointData2NV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCheckpointData2NV *>( this );
    }

    operator VkCheckpointData2NV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCheckpointData2NV const *>( this );
    }

    operator VkCheckpointData2NV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCheckpointData2NV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, PipelineStageFlags2 const &, void * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, stage, pCheckpointMarker );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CheckpointData2NV const & ) const = default;
#else
    bool operator==( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( pCheckpointMarker == rhs.pCheckpointMarker );
#  endif
    }

    bool operator!=( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType       sType             = StructureType::eCheckpointData2NV;
    void *              pNext             = {};
    PipelineStageFlags2 stage             = {};
    void *              pCheckpointMarker = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCheckpointData2NV>
  {
    using Type = CheckpointData2NV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCheckpointData2NV>
  {
    using Type = CheckpointData2NV;
  };

  // wrapper struct for struct VkCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCheckpointDataNV.html
  struct CheckpointDataNV
  {
    using NativeType = VkCheckpointDataNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCheckpointDataNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CheckpointDataNV( PipelineStageFlagBits stage_             = PipelineStageFlagBits::eTopOfPipe,
                                           void *                pCheckpointMarker_ = {},
                                           void *                pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , stage{ stage_ }
      , pCheckpointMarker{ pCheckpointMarker_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CheckpointDataNV( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT : CheckpointDataNV( *reinterpret_cast<CheckpointDataNV const *>( &rhs ) ) {}

    CheckpointDataNV & operator=( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CheckpointDataNV & operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CheckpointDataNV const *>( &rhs );
      return *this;
    }

    operator VkCheckpointDataNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCheckpointDataNV const *>( this );
    }

    operator VkCheckpointDataNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCheckpointDataNV *>( this );
    }

    operator VkCheckpointDataNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCheckpointDataNV const *>( this );
    }

    operator VkCheckpointDataNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCheckpointDataNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, PipelineStageFlagBits const &, void * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, stage, pCheckpointMarker );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CheckpointDataNV const & ) const = default;
#else
    bool operator==( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( pCheckpointMarker == rhs.pCheckpointMarker );
#  endif
    }

    bool operator!=( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType         sType             = StructureType::eCheckpointDataNV;
    void *                pNext             = {};
    PipelineStageFlagBits stage             = PipelineStageFlagBits::eTopOfPipe;
    void *                pCheckpointMarker = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCheckpointDataNV>
  {
    using Type = CheckpointDataNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCheckpointDataNV>
  {
    using Type = CheckpointDataNV;
  };

  union ClearColorValue
  {
    using NativeType = VkClearColorValue;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )

    VULKAN_HPP_CONSTEXPR_14 ClearColorValue( const std::array<float, 4> & float32_ = {} ) : float32( float32_ ) {}

    VULKAN_HPP_CONSTEXPR ClearColorValue( float float32_0, float float32_1, float float32_2, float float32_3 )
      : float32{ { { float32_0, float32_1, float32_2, float32_3 } } }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 ClearColorValue( const std::array<int32_t, 4> & int32_ ) : int32( int32_ ) {}

    VULKAN_HPP_CONSTEXPR ClearColorValue( int32_t int32_0, int32_t int32_1, int32_t int32_2, int32_t int32_3 )
      : int32{ { { int32_0, int32_1, int32_2, int32_3 } } }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 ClearColorValue( const std::array<uint32_t, 4> & uint32_ ) : uint32( uint32_ ) {}

    VULKAN_HPP_CONSTEXPR ClearColorValue( uint32_t uint32_0, uint32_t uint32_1, uint32_t uint32_2, uint32_t uint32_3 )
      : uint32{ { { uint32_0, uint32_1, uint32_2, uint32_3 } } }
    {
    }
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClearColorValue & setFloat32( std::array<float, 4> float32_ ) & VULKAN_HPP_NOEXCEPT
    {
      float32 = float32_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearColorValue && setFloat32( std::array<float, 4> float32_ ) && VULKAN_HPP_NOEXCEPT
    {
      float32 = float32_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClearColorValue & setInt32( std::array<int32_t, 4> int32_ ) & VULKAN_HPP_NOEXCEPT
    {
      int32 = int32_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearColorValue && setInt32( std::array<int32_t, 4> int32_ ) && VULKAN_HPP_NOEXCEPT
    {
      int32 = int32_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClearColorValue & setUint32( std::array<uint32_t, 4> uint32_ ) & VULKAN_HPP_NOEXCEPT
    {
      uint32 = uint32_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearColorValue && setUint32( std::array<uint32_t, 4> uint32_ ) && VULKAN_HPP_NOEXCEPT
    {
      uint32 = uint32_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClearColorValue const &() const
    {
      return *reinterpret_cast<VkClearColorValue const *>( this );
    }

    operator VkClearColorValue &()
    {
      return *reinterpret_cast<VkClearColorValue *>( this );
    }

    ArrayWrapper1D<float, 4>    float32;
    ArrayWrapper1D<int32_t, 4>  int32;
    ArrayWrapper1D<uint32_t, 4> uint32;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClearColorValue>
  {
    using Type = ClearColorValue;
  };
#endif

  // wrapper struct for struct VkClearDepthStencilValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkClearDepthStencilValue.html
  struct ClearDepthStencilValue
  {
    using NativeType = VkClearDepthStencilValue;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( float depth_ = {}, uint32_t stencil_ = {} ) VULKAN_HPP_NOEXCEPT
      : depth{ depth_ }
      , stencil{ stencil_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( ClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClearDepthStencilValue( *reinterpret_cast<ClearDepthStencilValue const *>( &rhs ) )
    {
    }

    ClearDepthStencilValue & operator=( ClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClearDepthStencilValue & operator=( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClearDepthStencilValue const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue & setDepth( float depth_ ) & VULKAN_HPP_NOEXCEPT
    {
      depth = depth_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue && setDepth( float depth_ ) && VULKAN_HPP_NOEXCEPT
    {
      depth = depth_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue & setStencil( uint32_t stencil_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencil = stencil_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue && setStencil( uint32_t stencil_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencil = stencil_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClearDepthStencilValue const *>( this );
    }

    operator VkClearDepthStencilValue &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClearDepthStencilValue *>( this );
    }

    operator VkClearDepthStencilValue const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClearDepthStencilValue const *>( this );
    }

    operator VkClearDepthStencilValue *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClearDepthStencilValue *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<float const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( depth, stencil );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClearDepthStencilValue const & ) const = default;
#else
    bool operator==( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( depth == rhs.depth ) && ( stencil == rhs.stencil );
#  endif
    }

    bool operator!=( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    float    depth   = {};
    uint32_t stencil = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClearDepthStencilValue>
  {
    using Type = ClearDepthStencilValue;
  };
#endif

  union ClearValue
  {
    using NativeType = VkClearValue;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )

    VULKAN_HPP_CONSTEXPR_14 ClearValue( ClearColorValue color_ = {} ) : color( color_ ) {}

    VULKAN_HPP_CONSTEXPR_14 ClearValue( ClearDepthStencilValue depthStencil_ ) : depthStencil( depthStencil_ ) {}
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClearValue & setColor( ClearColorValue const & color_ ) & VULKAN_HPP_NOEXCEPT
    {
      color = color_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearValue && setColor( ClearColorValue const & color_ ) && VULKAN_HPP_NOEXCEPT
    {
      color = color_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClearValue & setDepthStencil( ClearDepthStencilValue const & depthStencil_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthStencil = depthStencil_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearValue && setDepthStencil( ClearDepthStencilValue const & depthStencil_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthStencil = depthStencil_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClearValue const &() const
    {
      return *reinterpret_cast<VkClearValue const *>( this );
    }

    operator VkClearValue &()
    {
      return *reinterpret_cast<VkClearValue *>( this );
    }

#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    ClearColorValue        color;
    ClearDepthStencilValue depthStencil;
#else
    VkClearColorValue        color;
    VkClearDepthStencilValue depthStencil;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClearValue>
  {
    using Type = ClearValue;
  };
#endif

  // wrapper struct for struct VkClearAttachment, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkClearAttachment.html
  struct ClearAttachment
  {
    using NativeType = VkClearAttachment;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14
      ClearAttachment( ImageAspectFlags aspectMask_ = {}, uint32_t colorAttachment_ = {}, ClearValue clearValue_ = {} ) VULKAN_HPP_NOEXCEPT
      : aspectMask{ aspectMask_ }
      , colorAttachment{ colorAttachment_ }
      , clearValue{ clearValue_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 ClearAttachment( ClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClearAttachment( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT : ClearAttachment( *reinterpret_cast<ClearAttachment const *>( &rhs ) ) {}

    ClearAttachment & operator=( ClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClearAttachment & operator=( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClearAttachment const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClearAttachment & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearAttachment && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClearAttachment & setColorAttachment( uint32_t colorAttachment_ ) & VULKAN_HPP_NOEXCEPT
    {
      colorAttachment = colorAttachment_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearAttachment && setColorAttachment( uint32_t colorAttachment_ ) && VULKAN_HPP_NOEXCEPT
    {
      colorAttachment = colorAttachment_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClearAttachment & setClearValue( ClearValue const & clearValue_ ) & VULKAN_HPP_NOEXCEPT
    {
      clearValue = clearValue_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearAttachment && setClearValue( ClearValue const & clearValue_ ) && VULKAN_HPP_NOEXCEPT
    {
      clearValue = clearValue_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClearAttachment const *>( this );
    }

    operator VkClearAttachment &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClearAttachment *>( this );
    }

    operator VkClearAttachment const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClearAttachment const *>( this );
    }

    operator VkClearAttachment *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClearAttachment *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<ImageAspectFlags const &, uint32_t const &, ClearValue const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( aspectMask, colorAttachment, clearValue );
    }
#endif

  public:
    ImageAspectFlags aspectMask      = {};
    uint32_t         colorAttachment = {};
    ClearValue       clearValue      = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClearAttachment>
  {
    using Type = ClearAttachment;
  };
#endif

  // wrapper struct for struct VkClearRect, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkClearRect.html
  struct ClearRect
  {
    using NativeType = VkClearRect;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClearRect( Rect2D rect_ = {}, uint32_t baseArrayLayer_ = {}, uint32_t layerCount_ = {} ) VULKAN_HPP_NOEXCEPT
      : rect{ rect_ }
      , baseArrayLayer{ baseArrayLayer_ }
      , layerCount{ layerCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ClearRect( ClearRect const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClearRect( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT : ClearRect( *reinterpret_cast<ClearRect const *>( &rhs ) ) {}

    ClearRect & operator=( ClearRect const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClearRect & operator=( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClearRect const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClearRect & setRect( Rect2D const & rect_ ) & VULKAN_HPP_NOEXCEPT
    {
      rect = rect_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearRect && setRect( Rect2D const & rect_ ) && VULKAN_HPP_NOEXCEPT
    {
      rect = rect_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClearRect & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT
    {
      baseArrayLayer = baseArrayLayer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearRect && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT
    {
      baseArrayLayer = baseArrayLayer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClearRect & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      layerCount = layerCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClearRect && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      layerCount = layerCount_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClearRect const *>( this );
    }

    operator VkClearRect &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClearRect *>( this );
    }

    operator VkClearRect const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClearRect const *>( this );
    }

    operator VkClearRect *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClearRect *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<Rect2D const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( rect, baseArrayLayer, layerCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClearRect const & ) const = default;
#else
    bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( rect == rhs.rect ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount );
#  endif
    }

    bool operator!=( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    Rect2D   rect           = {};
    uint32_t baseArrayLayer = {};
    uint32_t layerCount     = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClearRect>
  {
    using Type = ClearRect;
  };
#endif

  // wrapper struct for struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV.html
  struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV
  {
    using NativeType = VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( uint32_t      clusterReferencesCount_  = {},
                                                                                     uint32_t      clusterReferencesStride_ = {},
                                                                                     DeviceAddress clusterReferences_       = {} ) VULKAN_HPP_NOEXCEPT
      : clusterReferencesCount{ clusterReferencesCount_ }
      , clusterReferencesStride{ clusterReferencesStride_ }
      , clusterReferences{ clusterReferences_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs )
      VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureBuildClustersBottomLevelInfoNV(
          *reinterpret_cast<ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureBuildClustersBottomLevelInfoNV &
      operator=( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureBuildClustersBottomLevelInfoNV &
      operator=( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & setClusterReferencesCount( uint32_t clusterReferencesCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      clusterReferencesCount = clusterReferencesCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV && setClusterReferencesCount( uint32_t clusterReferencesCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      clusterReferencesCount = clusterReferencesCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & setClusterReferencesStride( uint32_t clusterReferencesStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      clusterReferencesStride = clusterReferencesStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV && setClusterReferencesStride( uint32_t clusterReferencesStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      clusterReferencesStride = clusterReferencesStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & setClusterReferences( DeviceAddress clusterReferences_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      clusterReferences = clusterReferences_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV && setClusterReferences( DeviceAddress clusterReferences_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      clusterReferences = clusterReferences_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV *>( this );
    }

    operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, DeviceAddress const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( clusterReferencesCount, clusterReferencesStride, clusterReferences );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( clusterReferencesCount == rhs.clusterReferencesCount ) && ( clusterReferencesStride == rhs.clusterReferencesStride ) &&
             ( clusterReferences == rhs.clusterReferences );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t      clusterReferencesCount  = {};
    uint32_t      clusterReferencesStride = {};
    DeviceAddress clusterReferences       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV>
  {
    using Type = ClusterAccelerationStructureBuildClustersBottomLevelInfoNV;
  };
#endif

  // wrapper struct for struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.html
  struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV
  {
    using NativeType = VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( uint32_t geometryIndex_ = {},
                                                                                      uint32_t reserved_      = {},
                                                                                      uint32_t geometryFlags_ = {} ) VULKAN_HPP_NOEXCEPT
      : geometryIndex{ geometryIndex_ }
      , reserved{ reserved_ }
      , geometryFlags{ geometryFlags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs )
      VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV(
          *reinterpret_cast<ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV &
      operator=( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV &
      operator=( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & setGeometryIndex( uint32_t geometryIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometryIndex = geometryIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV && setGeometryIndex( uint32_t geometryIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      geometryIndex = geometryIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & setReserved( uint32_t reserved_ ) & VULKAN_HPP_NOEXCEPT
    {
      reserved = reserved_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV && setReserved( uint32_t reserved_ ) && VULKAN_HPP_NOEXCEPT
    {
      reserved = reserved_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & setGeometryFlags( uint32_t geometryFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometryFlags = geometryFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV && setGeometryFlags( uint32_t geometryFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      geometryFlags = geometryFlags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const *>( this );
    }

    operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV *>( this );
    }

    operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const *>( this );
    }

    operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( geometryIndex, reserved, geometryFlags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( geometryIndex == rhs.geometryIndex ) && ( reserved == rhs.reserved ) && ( geometryFlags == rhs.geometryFlags );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t geometryIndex : 24;
    uint32_t reserved      : 5;
    uint32_t geometryFlags : 3;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>
  {
    using Type = ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;
  };
#endif

  // wrapper struct for struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildTriangleClusterInfoNV.html
  struct ClusterAccelerationStructureBuildTriangleClusterInfoNV
  {
    using NativeType = VkClusterAccelerationStructureBuildTriangleClusterInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterInfoNV(
      uint32_t                                                    clusterID_                         = {},
      ClusterAccelerationStructureClusterFlagsNV                  clusterFlags_                      = {},
      uint32_t                                                    triangleCount_                     = {},
      uint32_t                                                    vertexCount_                       = {},
      uint32_t                                                    positionTruncateBitCount_          = {},
      uint32_t                                                    indexType_                         = {},
      uint32_t                                                    opacityMicromapIndexType_          = {},
      ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags_ = {},
      uint16_t                                                    indexBufferStride_                 = {},
      uint16_t                                                    vertexBufferStride_                = {},
      uint16_t                                                    geometryIndexAndFlagsBufferStride_ = {},
      uint16_t                                                    opacityMicromapIndexBufferStride_  = {},
      DeviceAddress                                               indexBuffer_                       = {},
      DeviceAddress                                               vertexBuffer_                      = {},
      DeviceAddress                                               geometryIndexAndFlagsBuffer_       = {},
      DeviceAddress                                               opacityMicromapArray_              = {},
      DeviceAddress                                               opacityMicromapIndexBuffer_        = {} ) VULKAN_HPP_NOEXCEPT
      : clusterID{ clusterID_ }
      , clusterFlags{ clusterFlags_ }
      , triangleCount{ triangleCount_ }
      , vertexCount{ vertexCount_ }
      , positionTruncateBitCount{ positionTruncateBitCount_ }
      , indexType{ indexType_ }
      , opacityMicromapIndexType{ opacityMicromapIndexType_ }
      , baseGeometryIndexAndGeometryFlags{ baseGeometryIndexAndGeometryFlags_ }
      , indexBufferStride{ indexBufferStride_ }
      , vertexBufferStride{ vertexBufferStride_ }
      , geometryIndexAndFlagsBufferStride{ geometryIndexAndFlagsBufferStride_ }
      , opacityMicromapIndexBufferStride{ opacityMicromapIndexBufferStride_ }
      , indexBuffer{ indexBuffer_ }
      , vertexBuffer{ vertexBuffer_ }
      , geometryIndexAndFlagsBuffer{ geometryIndexAndFlagsBuffer_ }
      , opacityMicromapArray{ opacityMicromapArray_ }
      , opacityMicromapIndexBuffer{ opacityMicromapIndexBuffer_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterInfoNV( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs )
      VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureBuildTriangleClusterInfoNV( VkClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureBuildTriangleClusterInfoNV( *reinterpret_cast<ClusterAccelerationStructureBuildTriangleClusterInfoNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureBuildTriangleClusterInfoNV &
      operator=( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureBuildTriangleClusterInfoNV &
      operator=( VkClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureBuildTriangleClusterInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setClusterID( uint32_t clusterID_ ) & VULKAN_HPP_NOEXCEPT
    {
      clusterID = clusterID_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setClusterID( uint32_t clusterID_ ) && VULKAN_HPP_NOEXCEPT
    {
      clusterID = clusterID_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &
      setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      clusterFlags = clusterFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &&
      setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      clusterFlags = clusterFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setTriangleCount( uint32_t triangleCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      triangleCount = triangleCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setTriangleCount( uint32_t triangleCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      triangleCount = triangleCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexCount = vertexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexCount = vertexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      positionTruncateBitCount = positionTruncateBitCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      positionTruncateBitCount = positionTruncateBitCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setIndexType( uint32_t indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setIndexType( uint32_t indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexType = opacityMicromapIndexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexType = opacityMicromapIndexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &
      setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &&
      setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setIndexBufferStride( uint16_t indexBufferStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexBufferStride = indexBufferStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setIndexBufferStride( uint16_t indexBufferStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexBufferStride = indexBufferStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setVertexBufferStride( uint16_t vertexBufferStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexBufferStride = vertexBufferStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setVertexBufferStride( uint16_t vertexBufferStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      vertexBufferStride = vertexBufferStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &
      setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &&
      setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &
      setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &&
      setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setIndexBuffer( DeviceAddress indexBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setIndexBuffer( DeviceAddress indexBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setVertexBuffer( DeviceAddress vertexBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexBuffer = vertexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setVertexBuffer( DeviceAddress vertexBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexBuffer = vertexBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &
      setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &&
      setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapArray = opacityMicromapArray_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapArray = opacityMicromapArray_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &
      setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV &&
      setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureBuildTriangleClusterInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureBuildTriangleClusterInfoNV *>( this );
    }

    operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureBuildTriangleClusterInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureBuildTriangleClusterInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &,
               ClusterAccelerationStructureClusterFlagsNV const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const &,
               uint16_t const &,
               uint16_t const &,
               uint16_t const &,
               uint16_t const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( clusterID,
                       clusterFlags,
                       triangleCount,
                       vertexCount,
                       positionTruncateBitCount,
                       indexType,
                       opacityMicromapIndexType,
                       baseGeometryIndexAndGeometryFlags,
                       indexBufferStride,
                       vertexBufferStride,
                       geometryIndexAndFlagsBufferStride,
                       opacityMicromapIndexBufferStride,
                       indexBuffer,
                       vertexBuffer,
                       geometryIndexAndFlagsBuffer,
                       opacityMicromapArray,
                       opacityMicromapIndexBuffer );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( clusterID == rhs.clusterID ) && ( clusterFlags == rhs.clusterFlags ) && ( triangleCount == rhs.triangleCount ) &&
             ( vertexCount == rhs.vertexCount ) && ( positionTruncateBitCount == rhs.positionTruncateBitCount ) && ( indexType == rhs.indexType ) &&
             ( opacityMicromapIndexType == rhs.opacityMicromapIndexType ) && ( baseGeometryIndexAndGeometryFlags == rhs.baseGeometryIndexAndGeometryFlags ) &&
             ( indexBufferStride == rhs.indexBufferStride ) && ( vertexBufferStride == rhs.vertexBufferStride ) &&
             ( geometryIndexAndFlagsBufferStride == rhs.geometryIndexAndFlagsBufferStride ) &&
             ( opacityMicromapIndexBufferStride == rhs.opacityMicromapIndexBufferStride ) && ( indexBuffer == rhs.indexBuffer ) &&
             ( vertexBuffer == rhs.vertexBuffer ) && ( geometryIndexAndFlagsBuffer == rhs.geometryIndexAndFlagsBuffer ) &&
             ( opacityMicromapArray == rhs.opacityMicromapArray ) && ( opacityMicromapIndexBuffer == rhs.opacityMicromapIndexBuffer );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t                                                    clusterID    = {};
    ClusterAccelerationStructureClusterFlagsNV                  clusterFlags = {};
    uint32_t                                                    triangleCount            : 9;
    uint32_t                                                    vertexCount              : 9;
    uint32_t                                                    positionTruncateBitCount : 6;
    uint32_t                                                    indexType                : 4;
    uint32_t                                                    opacityMicromapIndexType : 4;
    ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags = {};
    uint16_t                                                    indexBufferStride                 = {};
    uint16_t                                                    vertexBufferStride                = {};
    uint16_t                                                    geometryIndexAndFlagsBufferStride = {};
    uint16_t                                                    opacityMicromapIndexBufferStride  = {};
    DeviceAddress                                               indexBuffer                       = {};
    DeviceAddress                                               vertexBuffer                      = {};
    DeviceAddress                                               geometryIndexAndFlagsBuffer       = {};
    DeviceAddress                                               opacityMicromapArray              = {};
    DeviceAddress                                               opacityMicromapIndexBuffer        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureBuildTriangleClusterInfoNV>
  {
    using Type = ClusterAccelerationStructureBuildTriangleClusterInfoNV;
  };
#endif

  // wrapper struct for struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.html
  struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV
  {
    using NativeType = VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV(
      uint32_t                                                    clusterID_                         = {},
      ClusterAccelerationStructureClusterFlagsNV                  clusterFlags_                      = {},
      uint32_t                                                    triangleCount_                     = {},
      uint32_t                                                    vertexCount_                       = {},
      uint32_t                                                    positionTruncateBitCount_          = {},
      uint32_t                                                    indexType_                         = {},
      uint32_t                                                    opacityMicromapIndexType_          = {},
      ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags_ = {},
      uint16_t                                                    indexBufferStride_                 = {},
      uint16_t                                                    vertexBufferStride_                = {},
      uint16_t                                                    geometryIndexAndFlagsBufferStride_ = {},
      uint16_t                                                    opacityMicromapIndexBufferStride_  = {},
      DeviceAddress                                               indexBuffer_                       = {},
      DeviceAddress                                               vertexBuffer_                      = {},
      DeviceAddress                                               geometryIndexAndFlagsBuffer_       = {},
      DeviceAddress                                               opacityMicromapArray_              = {},
      DeviceAddress                                               opacityMicromapIndexBuffer_        = {},
      DeviceAddress                                               instantiationBoundingBoxLimit_     = {} ) VULKAN_HPP_NOEXCEPT
      : clusterID{ clusterID_ }
      , clusterFlags{ clusterFlags_ }
      , triangleCount{ triangleCount_ }
      , vertexCount{ vertexCount_ }
      , positionTruncateBitCount{ positionTruncateBitCount_ }
      , indexType{ indexType_ }
      , opacityMicromapIndexType{ opacityMicromapIndexType_ }
      , baseGeometryIndexAndGeometryFlags{ baseGeometryIndexAndGeometryFlags_ }
      , indexBufferStride{ indexBufferStride_ }
      , vertexBufferStride{ vertexBufferStride_ }
      , geometryIndexAndFlagsBufferStride{ geometryIndexAndFlagsBufferStride_ }
      , opacityMicromapIndexBufferStride{ opacityMicromapIndexBufferStride_ }
      , indexBuffer{ indexBuffer_ }
      , vertexBuffer{ vertexBuffer_ }
      , geometryIndexAndFlagsBuffer{ geometryIndexAndFlagsBuffer_ }
      , opacityMicromapArray{ opacityMicromapArray_ }
      , opacityMicromapIndexBuffer{ opacityMicromapIndexBuffer_ }
      , instantiationBoundingBoxLimit{ instantiationBoundingBoxLimit_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV(
      ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs )
      VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV(
          *reinterpret_cast<ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const *>( &rhs ) )
    {
    }

    explicit ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV(
      ClusterAccelerationStructureBuildTriangleClusterInfoNV const & clusterAccelerationStructureBuildTriangleClusterInfoNV,
      DeviceAddress                                                  instantiationBoundingBoxLimit_ = {} )
      : clusterID( clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterID )
      , clusterFlags( clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterFlags )
      , triangleCount( clusterAccelerationStructureBuildTriangleClusterInfoNV.triangleCount )
      , vertexCount( clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexCount )
      , positionTruncateBitCount( clusterAccelerationStructureBuildTriangleClusterInfoNV.positionTruncateBitCount )
      , indexType( clusterAccelerationStructureBuildTriangleClusterInfoNV.indexType )
      , opacityMicromapIndexType( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexType )
      , baseGeometryIndexAndGeometryFlags( clusterAccelerationStructureBuildTriangleClusterInfoNV.baseGeometryIndexAndGeometryFlags )
      , indexBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBufferStride )
      , vertexBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBufferStride )
      , geometryIndexAndFlagsBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBufferStride )
      , opacityMicromapIndexBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBufferStride )
      , indexBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBuffer )
      , vertexBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBuffer )
      , geometryIndexAndFlagsBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBuffer )
      , opacityMicromapArray( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapArray )
      , opacityMicromapIndexBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBuffer )
      , instantiationBoundingBoxLimit( instantiationBoundingBoxLimit_ )
    {
    }

    ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &
      operator=( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &
      operator=( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setClusterID( uint32_t clusterID_ ) & VULKAN_HPP_NOEXCEPT
    {
      clusterID = clusterID_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setClusterID( uint32_t clusterID_ ) && VULKAN_HPP_NOEXCEPT
    {
      clusterID = clusterID_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &
      setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      clusterFlags = clusterFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &&
      setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      clusterFlags = clusterFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setTriangleCount( uint32_t triangleCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      triangleCount = triangleCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setTriangleCount( uint32_t triangleCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      triangleCount = triangleCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexCount = vertexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexCount = vertexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      positionTruncateBitCount = positionTruncateBitCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &&
      setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      positionTruncateBitCount = positionTruncateBitCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setIndexType( uint32_t indexType_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setIndexType( uint32_t indexType_ ) && VULKAN_HPP_NOEXCEPT
    {
      indexType = indexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexType = opacityMicromapIndexType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &&
      setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexType = opacityMicromapIndexType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &
      setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &&
      setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setIndexBufferStride( uint16_t indexBufferStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      indexBufferStride = indexBufferStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setIndexBufferStride( uint16_t indexBufferStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indexBufferStride = indexBufferStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setVertexBufferStride( uint16_t vertexBufferStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      vertexBufferStride = vertexBufferStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setVertexBufferStride( uint16_t vertexBufferStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      vertexBufferStride = vertexBufferStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &
      setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &&
      setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &
      setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &&
      setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setIndexBuffer( DeviceAddress indexBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setIndexBuffer( DeviceAddress indexBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indexBuffer = indexBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setVertexBuffer( DeviceAddress vertexBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      vertexBuffer = vertexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setVertexBuffer( DeviceAddress vertexBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      vertexBuffer = vertexBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &
      setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &&
      setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapArray = opacityMicromapArray_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapArray = opacityMicromapArray_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &
      setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &&
      setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &
      setInstantiationBoundingBoxLimit( DeviceAddress instantiationBoundingBoxLimit_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      instantiationBoundingBoxLimit = instantiationBoundingBoxLimit_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &&
      setInstantiationBoundingBoxLimit( DeviceAddress instantiationBoundingBoxLimit_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      instantiationBoundingBoxLimit = instantiationBoundingBoxLimit_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV *>( this );
    }

    operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &,
               ClusterAccelerationStructureClusterFlagsNV const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const &,
               uint16_t const &,
               uint16_t const &,
               uint16_t const &,
               uint16_t const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &,
               DeviceAddress const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( clusterID,
                       clusterFlags,
                       triangleCount,
                       vertexCount,
                       positionTruncateBitCount,
                       indexType,
                       opacityMicromapIndexType,
                       baseGeometryIndexAndGeometryFlags,
                       indexBufferStride,
                       vertexBufferStride,
                       geometryIndexAndFlagsBufferStride,
                       opacityMicromapIndexBufferStride,
                       indexBuffer,
                       vertexBuffer,
                       geometryIndexAndFlagsBuffer,
                       opacityMicromapArray,
                       opacityMicromapIndexBuffer,
                       instantiationBoundingBoxLimit );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( clusterID == rhs.clusterID ) && ( clusterFlags == rhs.clusterFlags ) && ( triangleCount == rhs.triangleCount ) &&
             ( vertexCount == rhs.vertexCount ) && ( positionTruncateBitCount == rhs.positionTruncateBitCount ) && ( indexType == rhs.indexType ) &&
             ( opacityMicromapIndexType == rhs.opacityMicromapIndexType ) && ( baseGeometryIndexAndGeometryFlags == rhs.baseGeometryIndexAndGeometryFlags ) &&
             ( indexBufferStride == rhs.indexBufferStride ) && ( vertexBufferStride == rhs.vertexBufferStride ) &&
             ( geometryIndexAndFlagsBufferStride == rhs.geometryIndexAndFlagsBufferStride ) &&
             ( opacityMicromapIndexBufferStride == rhs.opacityMicromapIndexBufferStride ) && ( indexBuffer == rhs.indexBuffer ) &&
             ( vertexBuffer == rhs.vertexBuffer ) && ( geometryIndexAndFlagsBuffer == rhs.geometryIndexAndFlagsBuffer ) &&
             ( opacityMicromapArray == rhs.opacityMicromapArray ) && ( opacityMicromapIndexBuffer == rhs.opacityMicromapIndexBuffer ) &&
             ( instantiationBoundingBoxLimit == rhs.instantiationBoundingBoxLimit );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t                                                    clusterID    = {};
    ClusterAccelerationStructureClusterFlagsNV                  clusterFlags = {};
    uint32_t                                                    triangleCount            : 9;
    uint32_t                                                    vertexCount              : 9;
    uint32_t                                                    positionTruncateBitCount : 6;
    uint32_t                                                    indexType                : 4;
    uint32_t                                                    opacityMicromapIndexType : 4;
    ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags = {};
    uint16_t                                                    indexBufferStride                 = {};
    uint16_t                                                    vertexBufferStride                = {};
    uint16_t                                                    geometryIndexAndFlagsBufferStride = {};
    uint16_t                                                    opacityMicromapIndexBufferStride  = {};
    DeviceAddress                                               indexBuffer                       = {};
    DeviceAddress                                               vertexBuffer                      = {};
    DeviceAddress                                               geometryIndexAndFlagsBuffer       = {};
    DeviceAddress                                               opacityMicromapArray              = {};
    DeviceAddress                                               opacityMicromapIndexBuffer        = {};
    DeviceAddress                                               instantiationBoundingBoxLimit     = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV>
  {
    using Type = ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV;
  };
#endif

  // wrapper struct for struct VkClusterAccelerationStructureClustersBottomLevelInputNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClustersBottomLevelInputNV.html
  struct ClusterAccelerationStructureClustersBottomLevelInputNV
  {
    using NativeType = VkClusterAccelerationStructureClustersBottomLevelInputNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureClustersBottomLevelInputNV( uint32_t maxTotalClusterCount_                    = {},
                                                                                 uint32_t maxClusterCountPerAccelerationStructure_ = {},
                                                                                 void *   pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , maxTotalClusterCount{ maxTotalClusterCount_ }
      , maxClusterCountPerAccelerationStructure{ maxClusterCountPerAccelerationStructure_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureClustersBottomLevelInputNV( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs )
      VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureClustersBottomLevelInputNV( VkClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureClustersBottomLevelInputNV( *reinterpret_cast<ClusterAccelerationStructureClustersBottomLevelInputNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureClustersBottomLevelInputNV &
      operator=( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureClustersBottomLevelInputNV &
      operator=( VkClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureClustersBottomLevelInputNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV & setMaxTotalClusterCount( uint32_t maxTotalClusterCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxTotalClusterCount = maxTotalClusterCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV && setMaxTotalClusterCount( uint32_t maxTotalClusterCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxTotalClusterCount = maxTotalClusterCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV &
      setMaxClusterCountPerAccelerationStructure( uint32_t maxClusterCountPerAccelerationStructure_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxClusterCountPerAccelerationStructure = maxClusterCountPerAccelerationStructure_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV &&
      setMaxClusterCountPerAccelerationStructure( uint32_t maxClusterCountPerAccelerationStructure_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxClusterCountPerAccelerationStructure = maxClusterCountPerAccelerationStructure_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureClustersBottomLevelInputNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureClustersBottomLevelInputNV const *>( this );
    }

    operator VkClusterAccelerationStructureClustersBottomLevelInputNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureClustersBottomLevelInputNV *>( this );
    }

    operator VkClusterAccelerationStructureClustersBottomLevelInputNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureClustersBottomLevelInputNV const *>( this );
    }

    operator VkClusterAccelerationStructureClustersBottomLevelInputNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureClustersBottomLevelInputNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, maxTotalClusterCount, maxClusterCountPerAccelerationStructure );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureClustersBottomLevelInputNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTotalClusterCount == rhs.maxTotalClusterCount ) &&
             ( maxClusterCountPerAccelerationStructure == rhs.maxClusterCountPerAccelerationStructure );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                                   = StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV;
    void *        pNext                                   = {};
    uint32_t      maxTotalClusterCount                    = {};
    uint32_t      maxClusterCountPerAccelerationStructure = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureClustersBottomLevelInputNV>
  {
    using Type = ClusterAccelerationStructureClustersBottomLevelInputNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV>
  {
    using Type = ClusterAccelerationStructureClustersBottomLevelInputNV;
  };

  // wrapper struct for struct VkClusterAccelerationStructureTriangleClusterInputNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureTriangleClusterInputNV.html
  struct ClusterAccelerationStructureTriangleClusterInputNV
  {
    using NativeType = VkClusterAccelerationStructureTriangleClusterInputNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eClusterAccelerationStructureTriangleClusterInputNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureTriangleClusterInputNV( Format   vertexFormat_                  = Format::eUndefined,
                                                                             uint32_t maxGeometryIndexValue_         = {},
                                                                             uint32_t maxClusterUniqueGeometryCount_ = {},
                                                                             uint32_t maxClusterTriangleCount_       = {},
                                                                             uint32_t maxClusterVertexCount_         = {},
                                                                             uint32_t maxTotalTriangleCount_         = {},
                                                                             uint32_t maxTotalVertexCount_           = {},
                                                                             uint32_t minPositionTruncateBitCount_   = {},
                                                                             void *   pNext_                         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , vertexFormat{ vertexFormat_ }
      , maxGeometryIndexValue{ maxGeometryIndexValue_ }
      , maxClusterUniqueGeometryCount{ maxClusterUniqueGeometryCount_ }
      , maxClusterTriangleCount{ maxClusterTriangleCount_ }
      , maxClusterVertexCount{ maxClusterVertexCount_ }
      , maxTotalTriangleCount{ maxTotalTriangleCount_ }
      , maxTotalVertexCount{ maxTotalVertexCount_ }
      , minPositionTruncateBitCount{ minPositionTruncateBitCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      ClusterAccelerationStructureTriangleClusterInputNV( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureTriangleClusterInputNV( VkClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureTriangleClusterInputNV( *reinterpret_cast<ClusterAccelerationStructureTriangleClusterInputNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureTriangleClusterInputNV &
      operator=( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureTriangleClusterInputNV & operator=( VkClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureTriangleClusterInputNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexFormat = vertexFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxGeometryIndexValue( uint32_t maxGeometryIndexValue_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxGeometryIndexValue = maxGeometryIndexValue_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxGeometryIndexValue( uint32_t maxGeometryIndexValue_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxGeometryIndexValue = maxGeometryIndexValue_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxClusterUniqueGeometryCount( uint32_t maxClusterUniqueGeometryCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxClusterUniqueGeometryCount = maxClusterUniqueGeometryCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxClusterUniqueGeometryCount( uint32_t maxClusterUniqueGeometryCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxClusterUniqueGeometryCount = maxClusterUniqueGeometryCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxClusterTriangleCount( uint32_t maxClusterTriangleCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxClusterTriangleCount = maxClusterTriangleCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxClusterTriangleCount( uint32_t maxClusterTriangleCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxClusterTriangleCount = maxClusterTriangleCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxClusterVertexCount( uint32_t maxClusterVertexCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxClusterVertexCount = maxClusterVertexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxClusterVertexCount( uint32_t maxClusterVertexCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxClusterVertexCount = maxClusterVertexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxTotalTriangleCount( uint32_t maxTotalTriangleCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxTotalTriangleCount = maxTotalTriangleCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxTotalTriangleCount( uint32_t maxTotalTriangleCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxTotalTriangleCount = maxTotalTriangleCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxTotalVertexCount( uint32_t maxTotalVertexCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxTotalVertexCount = maxTotalVertexCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxTotalVertexCount( uint32_t maxTotalVertexCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxTotalVertexCount = maxTotalVertexCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMinPositionTruncateBitCount( uint32_t minPositionTruncateBitCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      minPositionTruncateBitCount = minPositionTruncateBitCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMinPositionTruncateBitCount( uint32_t minPositionTruncateBitCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      minPositionTruncateBitCount = minPositionTruncateBitCount_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureTriangleClusterInputNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureTriangleClusterInputNV const *>( this );
    }

    operator VkClusterAccelerationStructureTriangleClusterInputNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureTriangleClusterInputNV *>( this );
    }

    operator VkClusterAccelerationStructureTriangleClusterInputNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureTriangleClusterInputNV const *>( this );
    }

    operator VkClusterAccelerationStructureTriangleClusterInputNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureTriangleClusterInputNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               Format const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       vertexFormat,
                       maxGeometryIndexValue,
                       maxClusterUniqueGeometryCount,
                       maxClusterTriangleCount,
                       maxClusterVertexCount,
                       maxTotalTriangleCount,
                       maxTotalVertexCount,
                       minPositionTruncateBitCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureTriangleClusterInputNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexFormat == rhs.vertexFormat ) &&
             ( maxGeometryIndexValue == rhs.maxGeometryIndexValue ) && ( maxClusterUniqueGeometryCount == rhs.maxClusterUniqueGeometryCount ) &&
             ( maxClusterTriangleCount == rhs.maxClusterTriangleCount ) && ( maxClusterVertexCount == rhs.maxClusterVertexCount ) &&
             ( maxTotalTriangleCount == rhs.maxTotalTriangleCount ) && ( maxTotalVertexCount == rhs.maxTotalVertexCount ) &&
             ( minPositionTruncateBitCount == rhs.minPositionTruncateBitCount );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                         = StructureType::eClusterAccelerationStructureTriangleClusterInputNV;
    void *        pNext                         = {};
    Format        vertexFormat                  = Format::eUndefined;
    uint32_t      maxGeometryIndexValue         = {};
    uint32_t      maxClusterUniqueGeometryCount = {};
    uint32_t      maxClusterTriangleCount       = {};
    uint32_t      maxClusterVertexCount         = {};
    uint32_t      maxTotalTriangleCount         = {};
    uint32_t      maxTotalVertexCount           = {};
    uint32_t      minPositionTruncateBitCount   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureTriangleClusterInputNV>
  {
    using Type = ClusterAccelerationStructureTriangleClusterInputNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eClusterAccelerationStructureTriangleClusterInputNV>
  {
    using Type = ClusterAccelerationStructureTriangleClusterInputNV;
  };

  // wrapper struct for struct VkClusterAccelerationStructureMoveObjectsInputNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureMoveObjectsInputNV.html
  struct ClusterAccelerationStructureMoveObjectsInputNV
  {
    using NativeType = VkClusterAccelerationStructureMoveObjectsInputNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eClusterAccelerationStructureMoveObjectsInputNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      ClusterAccelerationStructureMoveObjectsInputNV( ClusterAccelerationStructureTypeNV type_ = ClusterAccelerationStructureTypeNV::eClustersBottomLevel,
                                                      Bool32                             noMoveOverlap_ = {},
                                                      DeviceSize                         maxMovedBytes_ = {},
                                                      void *                             pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , type{ type_ }
      , noMoveOverlap{ noMoveOverlap_ }
      , maxMovedBytes{ maxMovedBytes_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      ClusterAccelerationStructureMoveObjectsInputNV( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureMoveObjectsInputNV( VkClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureMoveObjectsInputNV( *reinterpret_cast<ClusterAccelerationStructureMoveObjectsInputNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureMoveObjectsInputNV & operator=( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureMoveObjectsInputNV & operator=( VkClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureMoveObjectsInputNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setType( ClusterAccelerationStructureTypeNV type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setType( ClusterAccelerationStructureTypeNV type_ ) && VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setNoMoveOverlap( Bool32 noMoveOverlap_ ) & VULKAN_HPP_NOEXCEPT
    {
      noMoveOverlap = noMoveOverlap_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setNoMoveOverlap( Bool32 noMoveOverlap_ ) && VULKAN_HPP_NOEXCEPT
    {
      noMoveOverlap = noMoveOverlap_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setMaxMovedBytes( DeviceSize maxMovedBytes_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxMovedBytes = maxMovedBytes_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setMaxMovedBytes( DeviceSize maxMovedBytes_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxMovedBytes = maxMovedBytes_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureMoveObjectsInputNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInputNV const *>( this );
    }

    operator VkClusterAccelerationStructureMoveObjectsInputNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInputNV *>( this );
    }

    operator VkClusterAccelerationStructureMoveObjectsInputNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInputNV const *>( this );
    }

    operator VkClusterAccelerationStructureMoveObjectsInputNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInputNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, ClusterAccelerationStructureTypeNV const &, Bool32 const &, DeviceSize const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, type, noMoveOverlap, maxMovedBytes );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureMoveObjectsInputNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( noMoveOverlap == rhs.noMoveOverlap ) &&
             ( maxMovedBytes == rhs.maxMovedBytes );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                      sType         = StructureType::eClusterAccelerationStructureMoveObjectsInputNV;
    void *                             pNext         = {};
    ClusterAccelerationStructureTypeNV type          = ClusterAccelerationStructureTypeNV::eClustersBottomLevel;
    Bool32                             noMoveOverlap = {};
    DeviceSize                         maxMovedBytes = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureMoveObjectsInputNV>
  {
    using Type = ClusterAccelerationStructureMoveObjectsInputNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eClusterAccelerationStructureMoveObjectsInputNV>
  {
    using Type = ClusterAccelerationStructureMoveObjectsInputNV;
  };

  union ClusterAccelerationStructureOpInputNV
  {
    using NativeType = VkClusterAccelerationStructureOpInputNV;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV( ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel_ = {} )
      : pClustersBottomLevel( pClustersBottomLevel_ )
    {
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV( ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters_ )
      : pTriangleClusters( pTriangleClusters_ )
    {
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV( ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects_ )
      : pMoveObjects( pMoveObjects_ )
    {
    }
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV &
      setPClustersBottomLevel( ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pClustersBottomLevel = pClustersBottomLevel_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV &&
      setPClustersBottomLevel( ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pClustersBottomLevel = pClustersBottomLevel_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV &
      setPTriangleClusters( ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pTriangleClusters = pTriangleClusters_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV &&
      setPTriangleClusters( ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pTriangleClusters = pTriangleClusters_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV & setPMoveObjects( ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pMoveObjects = pMoveObjects_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV && setPMoveObjects( ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pMoveObjects = pMoveObjects_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureOpInputNV const &() const
    {
      return *reinterpret_cast<VkClusterAccelerationStructureOpInputNV const *>( this );
    }

    operator VkClusterAccelerationStructureOpInputNV &()
    {
      return *reinterpret_cast<VkClusterAccelerationStructureOpInputNV *>( this );
    }

#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel;
    ClusterAccelerationStructureTriangleClusterInputNV *     pTriangleClusters;
    ClusterAccelerationStructureMoveObjectsInputNV *         pMoveObjects;
#else
    VkClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel;
    VkClusterAccelerationStructureTriangleClusterInputNV *     pTriangleClusters;
    VkClusterAccelerationStructureMoveObjectsInputNV *         pMoveObjects;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureOpInputNV>
  {
    using Type = ClusterAccelerationStructureOpInputNV;
  };
#endif

  // wrapper struct for struct VkClusterAccelerationStructureInputInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureInputInfoNV.html
  struct ClusterAccelerationStructureInputInfoNV
  {
    using NativeType = VkClusterAccelerationStructureInputInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eClusterAccelerationStructureInputInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14
      ClusterAccelerationStructureInputInfoNV( uint32_t                              maxAccelerationStructureCount_ = {},
                                               BuildAccelerationStructureFlagsKHR    flags_                         = {},
                                               ClusterAccelerationStructureOpTypeNV  opType_  = ClusterAccelerationStructureOpTypeNV::eMoveObjects,
                                               ClusterAccelerationStructureOpModeNV  opMode_  = ClusterAccelerationStructureOpModeNV::eImplicitDestinations,
                                               ClusterAccelerationStructureOpInputNV opInput_ = {},
                                               void *                                pNext_   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , maxAccelerationStructureCount{ maxAccelerationStructureCount_ }
      , flags{ flags_ }
      , opType{ opType_ }
      , opMode{ opMode_ }
      , opInput{ opInput_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV( ClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureInputInfoNV( VkClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureInputInfoNV( *reinterpret_cast<ClusterAccelerationStructureInputInfoNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureInputInfoNV & operator=( ClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureInputInfoNV & operator=( VkClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureInputInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setMaxAccelerationStructureCount( uint32_t maxAccelerationStructureCount_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxAccelerationStructureCount = maxAccelerationStructureCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setMaxAccelerationStructureCount( uint32_t maxAccelerationStructureCount_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxAccelerationStructureCount = maxAccelerationStructureCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setOpType( ClusterAccelerationStructureOpTypeNV opType_ ) & VULKAN_HPP_NOEXCEPT
    {
      opType = opType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setOpType( ClusterAccelerationStructureOpTypeNV opType_ ) && VULKAN_HPP_NOEXCEPT
    {
      opType = opType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setOpMode( ClusterAccelerationStructureOpModeNV opMode_ ) & VULKAN_HPP_NOEXCEPT
    {
      opMode = opMode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setOpMode( ClusterAccelerationStructureOpModeNV opMode_ ) && VULKAN_HPP_NOEXCEPT
    {
      opMode = opMode_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setOpInput( ClusterAccelerationStructureOpInputNV const & opInput_ ) & VULKAN_HPP_NOEXCEPT
    {
      opInput = opInput_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setOpInput( ClusterAccelerationStructureOpInputNV const & opInput_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      opInput = opInput_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureInputInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureInputInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureInputInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureInputInfoNV *>( this );
    }

    operator VkClusterAccelerationStructureInputInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureInputInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureInputInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureInputInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               uint32_t const &,
               BuildAccelerationStructureFlagsKHR const &,
               ClusterAccelerationStructureOpTypeNV const &,
               ClusterAccelerationStructureOpModeNV const &,
               ClusterAccelerationStructureOpInputNV const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, maxAccelerationStructureCount, flags, opType, opMode, opInput );
    }
#endif

  public:
    StructureType                         sType                         = StructureType::eClusterAccelerationStructureInputInfoNV;
    void *                                pNext                         = {};
    uint32_t                              maxAccelerationStructureCount = {};
    BuildAccelerationStructureFlagsKHR    flags                         = {};
    ClusterAccelerationStructureOpTypeNV  opType                        = ClusterAccelerationStructureOpTypeNV::eMoveObjects;
    ClusterAccelerationStructureOpModeNV  opMode                        = ClusterAccelerationStructureOpModeNV::eImplicitDestinations;
    ClusterAccelerationStructureOpInputNV opInput                       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureInputInfoNV>
  {
    using Type = ClusterAccelerationStructureInputInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eClusterAccelerationStructureInputInfoNV>
  {
    using Type = ClusterAccelerationStructureInputInfoNV;
  };

  // wrapper struct for struct VkStridedDeviceAddressRegionKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressRegionKHR.html
  struct StridedDeviceAddressRegionKHR
  {
    using NativeType = VkStridedDeviceAddressRegionKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR StridedDeviceAddressRegionKHR( DeviceAddress deviceAddress_ = {}, DeviceSize stride_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
      : deviceAddress{ deviceAddress_ }
      , stride{ stride_ }
      , size{ size_ }
    {
    }

    VULKAN_HPP_CONSTEXPR StridedDeviceAddressRegionKHR( StridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    StridedDeviceAddressRegionKHR( VkStridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : StridedDeviceAddressRegionKHR( *reinterpret_cast<StridedDeviceAddressRegionKHR const *>( &rhs ) )
    {
    }

    StridedDeviceAddressRegionKHR & operator=( StridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    StridedDeviceAddressRegionKHR & operator=( VkStridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<StridedDeviceAddressRegionKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkStridedDeviceAddressRegionKHR const *>( this );
    }

    operator VkStridedDeviceAddressRegionKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkStridedDeviceAddressRegionKHR *>( this );
    }

    operator VkStridedDeviceAddressRegionKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkStridedDeviceAddressRegionKHR const *>( this );
    }

    operator VkStridedDeviceAddressRegionKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkStridedDeviceAddressRegionKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, DeviceSize const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( deviceAddress, stride, size );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( StridedDeviceAddressRegionKHR const & ) const = default;
#else
    bool operator==( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( deviceAddress == rhs.deviceAddress ) && ( stride == rhs.stride ) && ( size == rhs.size );
#  endif
    }

    bool operator!=( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress deviceAddress = {};
    DeviceSize    stride        = {};
    DeviceSize    size          = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkStridedDeviceAddressRegionKHR>
  {
    using Type = StridedDeviceAddressRegionKHR;
  };
#endif

  // wrapper struct for struct VkClusterAccelerationStructureCommandsInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureCommandsInfoNV.html
  struct ClusterAccelerationStructureCommandsInfoNV
  {
    using NativeType = VkClusterAccelerationStructureCommandsInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eClusterAccelerationStructureCommandsInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV( ClusterAccelerationStructureInputInfoNV              input_                  = {},
                                                                        DeviceAddress                                        dstImplicitData_        = {},
                                                                        DeviceAddress                                        scratchData_            = {},
                                                                        StridedDeviceAddressRegionKHR                        dstAddressesArray_      = {},
                                                                        StridedDeviceAddressRegionKHR                        dstSizesArray_          = {},
                                                                        StridedDeviceAddressRegionKHR                        srcInfosArray_          = {},
                                                                        DeviceAddress                                        srcInfosCount_          = {},
                                                                        ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags_ = {},
                                                                        void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , input{ input_ }
      , dstImplicitData{ dstImplicitData_ }
      , scratchData{ scratchData_ }
      , dstAddressesArray{ dstAddressesArray_ }
      , dstSizesArray{ dstSizesArray_ }
      , srcInfosArray{ srcInfosArray_ }
      , srcInfosCount{ srcInfosCount_ }
      , addressResolutionFlags{ addressResolutionFlags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV( ClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureCommandsInfoNV( VkClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureCommandsInfoNV( *reinterpret_cast<ClusterAccelerationStructureCommandsInfoNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureCommandsInfoNV & operator=( ClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureCommandsInfoNV & operator=( VkClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureCommandsInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setInput( ClusterAccelerationStructureInputInfoNV const & input_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      input = input_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setInput( ClusterAccelerationStructureInputInfoNV const & input_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      input = input_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setDstImplicitData( DeviceAddress dstImplicitData_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImplicitData = dstImplicitData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setDstImplicitData( DeviceAddress dstImplicitData_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImplicitData = dstImplicitData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setScratchData( DeviceAddress scratchData_ ) & VULKAN_HPP_NOEXCEPT
    {
      scratchData = scratchData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setScratchData( DeviceAddress scratchData_ ) && VULKAN_HPP_NOEXCEPT
    {
      scratchData = scratchData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setDstAddressesArray( StridedDeviceAddressRegionKHR const & dstAddressesArray_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      dstAddressesArray = dstAddressesArray_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setDstAddressesArray( StridedDeviceAddressRegionKHR const & dstAddressesArray_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      dstAddressesArray = dstAddressesArray_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setDstSizesArray( StridedDeviceAddressRegionKHR const & dstSizesArray_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      dstSizesArray = dstSizesArray_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setDstSizesArray( StridedDeviceAddressRegionKHR const & dstSizesArray_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      dstSizesArray = dstSizesArray_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setSrcInfosArray( StridedDeviceAddressRegionKHR const & srcInfosArray_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      srcInfosArray = srcInfosArray_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setSrcInfosArray( StridedDeviceAddressRegionKHR const & srcInfosArray_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      srcInfosArray = srcInfosArray_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setSrcInfosCount( DeviceAddress srcInfosCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcInfosCount = srcInfosCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setSrcInfosCount( DeviceAddress srcInfosCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcInfosCount = srcInfosCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV &
      setAddressResolutionFlags( ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      addressResolutionFlags = addressResolutionFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV &&
      setAddressResolutionFlags( ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      addressResolutionFlags = addressResolutionFlags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureCommandsInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureCommandsInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureCommandsInfoNV *>( this );
    }

    operator VkClusterAccelerationStructureCommandsInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureCommandsInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureCommandsInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureCommandsInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               ClusterAccelerationStructureInputInfoNV const &,
               DeviceAddress const &,
               DeviceAddress const &,
               StridedDeviceAddressRegionKHR const &,
               StridedDeviceAddressRegionKHR const &,
               StridedDeviceAddressRegionKHR const &,
               DeviceAddress const &,
               ClusterAccelerationStructureAddressResolutionFlagsNV const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie(
        sType, pNext, input, dstImplicitData, scratchData, dstAddressesArray, dstSizesArray, srcInfosArray, srcInfosCount, addressResolutionFlags );
    }
#endif

  public:
    StructureType                                        sType                  = StructureType::eClusterAccelerationStructureCommandsInfoNV;
    void *                                               pNext                  = {};
    ClusterAccelerationStructureInputInfoNV              input                  = {};
    DeviceAddress                                        dstImplicitData        = {};
    DeviceAddress                                        scratchData            = {};
    StridedDeviceAddressRegionKHR                        dstAddressesArray      = {};
    StridedDeviceAddressRegionKHR                        dstSizesArray          = {};
    StridedDeviceAddressRegionKHR                        srcInfosArray          = {};
    DeviceAddress                                        srcInfosCount          = {};
    ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureCommandsInfoNV>
  {
    using Type = ClusterAccelerationStructureCommandsInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eClusterAccelerationStructureCommandsInfoNV>
  {
    using Type = ClusterAccelerationStructureCommandsInfoNV;
  };

  // wrapper struct for struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGetTemplateIndicesInfoNV.html
  struct ClusterAccelerationStructureGetTemplateIndicesInfoNV
  {
    using NativeType = VkClusterAccelerationStructureGetTemplateIndicesInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureGetTemplateIndicesInfoNV( DeviceAddress clusterTemplateAddress_ = {} ) VULKAN_HPP_NOEXCEPT
      : clusterTemplateAddress{ clusterTemplateAddress_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      ClusterAccelerationStructureGetTemplateIndicesInfoNV( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureGetTemplateIndicesInfoNV( VkClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureGetTemplateIndicesInfoNV( *reinterpret_cast<ClusterAccelerationStructureGetTemplateIndicesInfoNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureGetTemplateIndicesInfoNV &
      operator=( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureGetTemplateIndicesInfoNV & operator=( VkClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureGetTemplateIndicesInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGetTemplateIndicesInfoNV & setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      clusterTemplateAddress = clusterTemplateAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGetTemplateIndicesInfoNV && setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      clusterTemplateAddress = clusterTemplateAddress_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureGetTemplateIndicesInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureGetTemplateIndicesInfoNV *>( this );
    }

    operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureGetTemplateIndicesInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureGetTemplateIndicesInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( clusterTemplateAddress );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( clusterTemplateAddress == rhs.clusterTemplateAddress );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress clusterTemplateAddress = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureGetTemplateIndicesInfoNV>
  {
    using Type = ClusterAccelerationStructureGetTemplateIndicesInfoNV;
  };
#endif

  // wrapper struct for struct VkClusterAccelerationStructureInstantiateClusterInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureInstantiateClusterInfoNV.html
  struct ClusterAccelerationStructureInstantiateClusterInfoNV
  {
    using NativeType = VkClusterAccelerationStructureInstantiateClusterInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureInstantiateClusterInfoNV( uint32_t               clusterIdOffset_        = {},
                                                                               uint32_t               geometryIndexOffset_    = {},
                                                                               uint32_t               reserved_               = {},
                                                                               DeviceAddress          clusterTemplateAddress_ = {},
                                                                               StridedDeviceAddressNV vertexBuffer_           = {} ) VULKAN_HPP_NOEXCEPT
      : clusterIdOffset{ clusterIdOffset_ }
      , geometryIndexOffset{ geometryIndexOffset_ }
      , reserved{ reserved_ }
      , clusterTemplateAddress{ clusterTemplateAddress_ }
      , vertexBuffer{ vertexBuffer_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      ClusterAccelerationStructureInstantiateClusterInfoNV( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureInstantiateClusterInfoNV( VkClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureInstantiateClusterInfoNV( *reinterpret_cast<ClusterAccelerationStructureInstantiateClusterInfoNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureInstantiateClusterInfoNV &
      operator=( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureInstantiateClusterInfoNV & operator=( VkClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureInstantiateClusterInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setClusterIdOffset( uint32_t clusterIdOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      clusterIdOffset = clusterIdOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setClusterIdOffset( uint32_t clusterIdOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      clusterIdOffset = clusterIdOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setGeometryIndexOffset( uint32_t geometryIndexOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometryIndexOffset = geometryIndexOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setGeometryIndexOffset( uint32_t geometryIndexOffset_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      geometryIndexOffset = geometryIndexOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setReserved( uint32_t reserved_ ) & VULKAN_HPP_NOEXCEPT
    {
      reserved = reserved_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setReserved( uint32_t reserved_ ) && VULKAN_HPP_NOEXCEPT
    {
      reserved = reserved_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      clusterTemplateAddress = clusterTemplateAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      clusterTemplateAddress = clusterTemplateAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setVertexBuffer( StridedDeviceAddressNV const & vertexBuffer_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      vertexBuffer = vertexBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setVertexBuffer( StridedDeviceAddressNV const & vertexBuffer_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      vertexBuffer = vertexBuffer_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureInstantiateClusterInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureInstantiateClusterInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureInstantiateClusterInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureInstantiateClusterInfoNV *>( this );
    }

    operator VkClusterAccelerationStructureInstantiateClusterInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureInstantiateClusterInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureInstantiateClusterInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureInstantiateClusterInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, DeviceAddress const &, StridedDeviceAddressNV const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( clusterIdOffset, geometryIndexOffset, reserved, clusterTemplateAddress, vertexBuffer );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureInstantiateClusterInfoNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( clusterIdOffset == rhs.clusterIdOffset ) && ( geometryIndexOffset == rhs.geometryIndexOffset ) && ( reserved == rhs.reserved ) &&
             ( clusterTemplateAddress == rhs.clusterTemplateAddress ) && ( vertexBuffer == rhs.vertexBuffer );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t               clusterIdOffset = {};
    uint32_t               geometryIndexOffset : 24;
    uint32_t               reserved            : 8;
    DeviceAddress          clusterTemplateAddress = {};
    StridedDeviceAddressNV vertexBuffer           = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureInstantiateClusterInfoNV>
  {
    using Type = ClusterAccelerationStructureInstantiateClusterInfoNV;
  };
#endif

  // wrapper struct for struct VkClusterAccelerationStructureMoveObjectsInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureMoveObjectsInfoNV.html
  struct ClusterAccelerationStructureMoveObjectsInfoNV
  {
    using NativeType = VkClusterAccelerationStructureMoveObjectsInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureMoveObjectsInfoNV( DeviceAddress srcAccelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT
      : srcAccelerationStructure{ srcAccelerationStructure_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      ClusterAccelerationStructureMoveObjectsInfoNV( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ClusterAccelerationStructureMoveObjectsInfoNV( VkClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ClusterAccelerationStructureMoveObjectsInfoNV( *reinterpret_cast<ClusterAccelerationStructureMoveObjectsInfoNV const *>( &rhs ) )
    {
    }

    ClusterAccelerationStructureMoveObjectsInfoNV & operator=( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ClusterAccelerationStructureMoveObjectsInfoNV & operator=( VkClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ClusterAccelerationStructureMoveObjectsInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInfoNV & setSrcAccelerationStructure( DeviceAddress srcAccelerationStructure_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      srcAccelerationStructure = srcAccelerationStructure_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInfoNV && setSrcAccelerationStructure( DeviceAddress srcAccelerationStructure_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      srcAccelerationStructure = srcAccelerationStructure_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkClusterAccelerationStructureMoveObjectsInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureMoveObjectsInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInfoNV *>( this );
    }

    operator VkClusterAccelerationStructureMoveObjectsInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInfoNV const *>( this );
    }

    operator VkClusterAccelerationStructureMoveObjectsInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( srcAccelerationStructure );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ClusterAccelerationStructureMoveObjectsInfoNV const & ) const = default;
#else
    bool operator==( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( srcAccelerationStructure == rhs.srcAccelerationStructure );
#  endif
    }

    bool operator!=( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress srcAccelerationStructure = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkClusterAccelerationStructureMoveObjectsInfoNV>
  {
    using Type = ClusterAccelerationStructureMoveObjectsInfoNV;
  };
#endif

  // wrapper struct for struct VkCoarseSampleLocationNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoarseSampleLocationNV.html
  struct CoarseSampleLocationNV
  {
    using NativeType = VkCoarseSampleLocationNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( uint32_t pixelX_ = {}, uint32_t pixelY_ = {}, uint32_t sample_ = {} ) VULKAN_HPP_NOEXCEPT
      : pixelX{ pixelX_ }
      , pixelY{ pixelY_ }
      , sample{ sample_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( CoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : CoarseSampleLocationNV( *reinterpret_cast<CoarseSampleLocationNV const *>( &rhs ) )
    {
    }

    CoarseSampleLocationNV & operator=( CoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CoarseSampleLocationNV & operator=( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CoarseSampleLocationNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV & setPixelX( uint32_t pixelX_ ) & VULKAN_HPP_NOEXCEPT
    {
      pixelX = pixelX_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV && setPixelX( uint32_t pixelX_ ) && VULKAN_HPP_NOEXCEPT
    {
      pixelX = pixelX_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV & setPixelY( uint32_t pixelY_ ) & VULKAN_HPP_NOEXCEPT
    {
      pixelY = pixelY_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV && setPixelY( uint32_t pixelY_ ) && VULKAN_HPP_NOEXCEPT
    {
      pixelY = pixelY_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV & setSample( uint32_t sample_ ) & VULKAN_HPP_NOEXCEPT
    {
      sample = sample_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV && setSample( uint32_t sample_ ) && VULKAN_HPP_NOEXCEPT
    {
      sample = sample_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCoarseSampleLocationNV const *>( this );
    }

    operator VkCoarseSampleLocationNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCoarseSampleLocationNV *>( this );
    }

    operator VkCoarseSampleLocationNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCoarseSampleLocationNV const *>( this );
    }

    operator VkCoarseSampleLocationNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCoarseSampleLocationNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( pixelX, pixelY, sample );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CoarseSampleLocationNV const & ) const = default;
#else
    bool operator==( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( pixelX == rhs.pixelX ) && ( pixelY == rhs.pixelY ) && ( sample == rhs.sample );
#  endif
    }

    bool operator!=( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t pixelX = {};
    uint32_t pixelY = {};
    uint32_t sample = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCoarseSampleLocationNV>
  {
    using Type = CoarseSampleLocationNV;
  };
#endif

  // wrapper struct for struct VkCoarseSampleOrderCustomNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoarseSampleOrderCustomNV.html
  struct CoarseSampleOrderCustomNV
  {
    using NativeType = VkCoarseSampleOrderCustomNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV      shadingRate_         = ShadingRatePaletteEntryNV::eNoInvocations,
                                                    uint32_t                       sampleCount_         = {},
                                                    uint32_t                       sampleLocationCount_ = {},
                                                    CoarseSampleLocationNV const * pSampleLocations_    = {} ) VULKAN_HPP_NOEXCEPT
      : shadingRate{ shadingRate_ }
      , sampleCount{ sampleCount_ }
      , sampleLocationCount{ sampleLocationCount_ }
      , pSampleLocations{ pSampleLocations_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( CoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : CoarseSampleOrderCustomNV( *reinterpret_cast<CoarseSampleOrderCustomNV const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV                                     shadingRate_,
                               uint32_t                                                      sampleCount_,
                               ArrayProxyNoTemporaries<CoarseSampleLocationNV const> const & sampleLocations_ )
      : shadingRate( shadingRate_ )
      , sampleCount( sampleCount_ )
      , sampleLocationCount( static_cast<uint32_t>( sampleLocations_.size() ) )
      , pSampleLocations( sampleLocations_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CoarseSampleOrderCustomNV & operator=( CoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CoarseSampleOrderCustomNV & operator=( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CoarseSampleOrderCustomNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setShadingRate( ShadingRatePaletteEntryNV shadingRate_ ) & VULKAN_HPP_NOEXCEPT
    {
      shadingRate = shadingRate_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setShadingRate( ShadingRatePaletteEntryNV shadingRate_ ) && VULKAN_HPP_NOEXCEPT
    {
      shadingRate = shadingRate_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setSampleCount( uint32_t sampleCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      sampleCount = sampleCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setSampleCount( uint32_t sampleCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      sampleCount = sampleCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setSampleLocationCount( uint32_t sampleLocationCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      sampleLocationCount = sampleLocationCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setSampleLocationCount( uint32_t sampleLocationCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      sampleLocationCount = sampleLocationCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setPSampleLocations( CoarseSampleLocationNV const * pSampleLocations_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSampleLocations = pSampleLocations_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setPSampleLocations( CoarseSampleLocationNV const * pSampleLocations_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSampleLocations = pSampleLocations_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CoarseSampleOrderCustomNV & setSampleLocations( ArrayProxyNoTemporaries<CoarseSampleLocationNV const> const & sampleLocations_ ) VULKAN_HPP_NOEXCEPT
    {
      sampleLocationCount = static_cast<uint32_t>( sampleLocations_.size() );
      pSampleLocations    = sampleLocations_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCoarseSampleOrderCustomNV const *>( this );
    }

    operator VkCoarseSampleOrderCustomNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCoarseSampleOrderCustomNV *>( this );
    }

    operator VkCoarseSampleOrderCustomNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCoarseSampleOrderCustomNV const *>( this );
    }

    operator VkCoarseSampleOrderCustomNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCoarseSampleOrderCustomNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<ShadingRatePaletteEntryNV const &, uint32_t const &, uint32_t const &, CoarseSampleLocationNV const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( shadingRate, sampleCount, sampleLocationCount, pSampleLocations );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CoarseSampleOrderCustomNV const & ) const = default;
#else
    bool operator==( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( shadingRate == rhs.shadingRate ) && ( sampleCount == rhs.sampleCount ) && ( sampleLocationCount == rhs.sampleLocationCount ) &&
             ( pSampleLocations == rhs.pSampleLocations );
#  endif
    }

    bool operator!=( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    ShadingRatePaletteEntryNV      shadingRate         = ShadingRatePaletteEntryNV::eNoInvocations;
    uint32_t                       sampleCount         = {};
    uint32_t                       sampleLocationCount = {};
    CoarseSampleLocationNV const * pSampleLocations    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCoarseSampleOrderCustomNV>
  {
    using Type = CoarseSampleOrderCustomNV;
  };
#endif

  // wrapper struct for struct VkColorBlendAdvancedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorBlendAdvancedEXT.html
  struct ColorBlendAdvancedEXT
  {
    using NativeType = VkColorBlendAdvancedEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ColorBlendAdvancedEXT( BlendOp         advancedBlendOp_  = BlendOp::eAdd,
                                                Bool32          srcPremultiplied_ = {},
                                                Bool32          dstPremultiplied_ = {},
                                                BlendOverlapEXT blendOverlap_     = BlendOverlapEXT::eUncorrelated,
                                                Bool32          clampResults_     = {} ) VULKAN_HPP_NOEXCEPT
      : advancedBlendOp{ advancedBlendOp_ }
      , srcPremultiplied{ srcPremultiplied_ }
      , dstPremultiplied{ dstPremultiplied_ }
      , blendOverlap{ blendOverlap_ }
      , clampResults{ clampResults_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ColorBlendAdvancedEXT( ColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ColorBlendAdvancedEXT( VkColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : ColorBlendAdvancedEXT( *reinterpret_cast<ColorBlendAdvancedEXT const *>( &rhs ) )
    {
    }

    ColorBlendAdvancedEXT & operator=( ColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ColorBlendAdvancedEXT & operator=( VkColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ColorBlendAdvancedEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setAdvancedBlendOp( BlendOp advancedBlendOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      advancedBlendOp = advancedBlendOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setAdvancedBlendOp( BlendOp advancedBlendOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      advancedBlendOp = advancedBlendOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setSrcPremultiplied( Bool32 srcPremultiplied_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcPremultiplied = srcPremultiplied_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setSrcPremultiplied( Bool32 srcPremultiplied_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcPremultiplied = srcPremultiplied_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setDstPremultiplied( Bool32 dstPremultiplied_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstPremultiplied = dstPremultiplied_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setDstPremultiplied( Bool32 dstPremultiplied_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstPremultiplied = dstPremultiplied_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setBlendOverlap( BlendOverlapEXT blendOverlap_ ) & VULKAN_HPP_NOEXCEPT
    {
      blendOverlap = blendOverlap_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setBlendOverlap( BlendOverlapEXT blendOverlap_ ) && VULKAN_HPP_NOEXCEPT
    {
      blendOverlap = blendOverlap_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setClampResults( Bool32 clampResults_ ) & VULKAN_HPP_NOEXCEPT
    {
      clampResults = clampResults_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setClampResults( Bool32 clampResults_ ) && VULKAN_HPP_NOEXCEPT
    {
      clampResults = clampResults_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkColorBlendAdvancedEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkColorBlendAdvancedEXT const *>( this );
    }

    operator VkColorBlendAdvancedEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkColorBlendAdvancedEXT *>( this );
    }

    operator VkColorBlendAdvancedEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkColorBlendAdvancedEXT const *>( this );
    }

    operator VkColorBlendAdvancedEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkColorBlendAdvancedEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<BlendOp const &, Bool32 const &, Bool32 const &, BlendOverlapEXT const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( advancedBlendOp, srcPremultiplied, dstPremultiplied, blendOverlap, clampResults );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ColorBlendAdvancedEXT const & ) const = default;
#else
    bool operator==( ColorBlendAdvancedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( advancedBlendOp == rhs.advancedBlendOp ) && ( srcPremultiplied == rhs.srcPremultiplied ) && ( dstPremultiplied == rhs.dstPremultiplied ) &&
             ( blendOverlap == rhs.blendOverlap ) && ( clampResults == rhs.clampResults );
#  endif
    }

    bool operator!=( ColorBlendAdvancedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    BlendOp         advancedBlendOp  = BlendOp::eAdd;
    Bool32          srcPremultiplied = {};
    Bool32          dstPremultiplied = {};
    BlendOverlapEXT blendOverlap     = BlendOverlapEXT::eUncorrelated;
    Bool32          clampResults     = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkColorBlendAdvancedEXT>
  {
    using Type = ColorBlendAdvancedEXT;
  };
#endif

  // wrapper struct for struct VkColorBlendEquationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorBlendEquationEXT.html
  struct ColorBlendEquationEXT
  {
    using NativeType = VkColorBlendEquationEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ColorBlendEquationEXT( BlendFactor srcColorBlendFactor_ = BlendFactor::eZero,
                                                BlendFactor dstColorBlendFactor_ = BlendFactor::eZero,
                                                BlendOp     colorBlendOp_        = BlendOp::eAdd,
                                                BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero,
                                                BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero,
                                                BlendOp     alphaBlendOp_        = BlendOp::eAdd ) VULKAN_HPP_NOEXCEPT
      : srcColorBlendFactor{ srcColorBlendFactor_ }
      , dstColorBlendFactor{ dstColorBlendFactor_ }
      , colorBlendOp{ colorBlendOp_ }
      , srcAlphaBlendFactor{ srcAlphaBlendFactor_ }
      , dstAlphaBlendFactor{ dstAlphaBlendFactor_ }
      , alphaBlendOp{ alphaBlendOp_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ColorBlendEquationEXT( ColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ColorBlendEquationEXT( VkColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : ColorBlendEquationEXT( *reinterpret_cast<ColorBlendEquationEXT const *>( &rhs ) )
    {
    }

    ColorBlendEquationEXT & operator=( ColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ColorBlendEquationEXT & operator=( VkColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ColorBlendEquationEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcColorBlendFactor = srcColorBlendFactor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcColorBlendFactor = srcColorBlendFactor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstColorBlendFactor = dstColorBlendFactor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstColorBlendFactor = dstColorBlendFactor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setColorBlendOp( BlendOp colorBlendOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      colorBlendOp = colorBlendOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setColorBlendOp( BlendOp colorBlendOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      colorBlendOp = colorBlendOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcAlphaBlendFactor = srcAlphaBlendFactor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcAlphaBlendFactor = srcAlphaBlendFactor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstAlphaBlendFactor = dstAlphaBlendFactor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstAlphaBlendFactor = dstAlphaBlendFactor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setAlphaBlendOp( BlendOp alphaBlendOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      alphaBlendOp = alphaBlendOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setAlphaBlendOp( BlendOp alphaBlendOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      alphaBlendOp = alphaBlendOp_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkColorBlendEquationEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkColorBlendEquationEXT const *>( this );
    }

    operator VkColorBlendEquationEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkColorBlendEquationEXT *>( this );
    }

    operator VkColorBlendEquationEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkColorBlendEquationEXT const *>( this );
    }

    operator VkColorBlendEquationEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkColorBlendEquationEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<BlendFactor const &, BlendFactor const &, BlendOp const &, BlendFactor const &, BlendFactor const &, BlendOp const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( srcColorBlendFactor, dstColorBlendFactor, colorBlendOp, srcAlphaBlendFactor, dstAlphaBlendFactor, alphaBlendOp );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ColorBlendEquationEXT const & ) const = default;
#else
    bool operator==( ColorBlendEquationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( srcColorBlendFactor == rhs.srcColorBlendFactor ) && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && ( colorBlendOp == rhs.colorBlendOp ) &&
             ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) && ( alphaBlendOp == rhs.alphaBlendOp );
#  endif
    }

    bool operator!=( ColorBlendEquationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    BlendFactor srcColorBlendFactor = BlendFactor::eZero;
    BlendFactor dstColorBlendFactor = BlendFactor::eZero;
    BlendOp     colorBlendOp        = BlendOp::eAdd;
    BlendFactor srcAlphaBlendFactor = BlendFactor::eZero;
    BlendFactor dstAlphaBlendFactor = BlendFactor::eZero;
    BlendOp     alphaBlendOp        = BlendOp::eAdd;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkColorBlendEquationEXT>
  {
    using Type = ColorBlendEquationEXT;
  };
#endif

  // wrapper struct for struct VkCommandBufferAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferAllocateInfo.html
  struct CommandBufferAllocateInfo
  {
    using NativeType = VkCommandBufferAllocateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandBufferAllocateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( CommandPool        commandPool_        = {},
                                                    CommandBufferLevel level_              = CommandBufferLevel::ePrimary,
                                                    uint32_t           commandBufferCount_ = {},
                                                    void const *       pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , commandPool{ commandPool_ }
      , level{ level_ }
      , commandBufferCount{ commandBufferCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandBufferAllocateInfo( *reinterpret_cast<CommandBufferAllocateInfo const *>( &rhs ) )
    {
    }

    CommandBufferAllocateInfo & operator=( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandBufferAllocateInfo & operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandBufferAllocateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setCommandPool( CommandPool commandPool_ ) & VULKAN_HPP_NOEXCEPT
    {
      commandPool = commandPool_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setCommandPool( CommandPool commandPool_ ) && VULKAN_HPP_NOEXCEPT
    {
      commandPool = commandPool_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setLevel( CommandBufferLevel level_ ) & VULKAN_HPP_NOEXCEPT
    {
      level = level_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setLevel( CommandBufferLevel level_ ) && VULKAN_HPP_NOEXCEPT
    {
      level = level_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setCommandBufferCount( uint32_t commandBufferCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      commandBufferCount = commandBufferCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setCommandBufferCount( uint32_t commandBufferCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      commandBufferCount = commandBufferCount_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferAllocateInfo const *>( this );
    }

    operator VkCommandBufferAllocateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferAllocateInfo *>( this );
    }

    operator VkCommandBufferAllocateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferAllocateInfo const *>( this );
    }

    operator VkCommandBufferAllocateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferAllocateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, CommandPool const &, CommandBufferLevel const &, uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, commandPool, level, commandBufferCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandBufferAllocateInfo const & ) const = default;
#else
    bool operator==( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) && ( level == rhs.level ) &&
             ( commandBufferCount == rhs.commandBufferCount );
#  endif
    }

    bool operator!=( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType      sType              = StructureType::eCommandBufferAllocateInfo;
    void const *       pNext              = {};
    CommandPool        commandPool        = {};
    CommandBufferLevel level              = CommandBufferLevel::ePrimary;
    uint32_t           commandBufferCount = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandBufferAllocateInfo>
  {
    using Type = CommandBufferAllocateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandBufferAllocateInfo>
  {
    using Type = CommandBufferAllocateInfo;
  };

  // wrapper struct for struct VkCommandBufferInheritanceInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceInfo.html
  struct CommandBufferInheritanceInfo
  {
    using NativeType = VkCommandBufferInheritanceInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandBufferInheritanceInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( RenderPass                  renderPass_           = {},
                                                       uint32_t                    subpass_              = {},
                                                       Framebuffer                 framebuffer_          = {},
                                                       Bool32                      occlusionQueryEnable_ = {},
                                                       QueryControlFlags           queryFlags_           = {},
                                                       QueryPipelineStatisticFlags pipelineStatistics_   = {},
                                                       void const *                pNext_                = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , renderPass{ renderPass_ }
      , subpass{ subpass_ }
      , framebuffer{ framebuffer_ }
      , occlusionQueryEnable{ occlusionQueryEnable_ }
      , queryFlags{ queryFlags_ }
      , pipelineStatistics{ pipelineStatistics_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandBufferInheritanceInfo( *reinterpret_cast<CommandBufferInheritanceInfo const *>( &rhs ) )
    {
    }

    CommandBufferInheritanceInfo & operator=( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandBufferInheritanceInfo & operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandBufferInheritanceInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT
    {
      renderPass = renderPass_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT
    {
      renderPass = renderPass_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setSubpass( uint32_t subpass_ ) & VULKAN_HPP_NOEXCEPT
    {
      subpass = subpass_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setSubpass( uint32_t subpass_ ) && VULKAN_HPP_NOEXCEPT
    {
      subpass = subpass_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setFramebuffer( Framebuffer framebuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      framebuffer = framebuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setFramebuffer( Framebuffer framebuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      framebuffer = framebuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) & VULKAN_HPP_NOEXCEPT
    {
      occlusionQueryEnable = occlusionQueryEnable_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) && VULKAN_HPP_NOEXCEPT
    {
      occlusionQueryEnable = occlusionQueryEnable_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setQueryFlags( QueryControlFlags queryFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      queryFlags = queryFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setQueryFlags( QueryControlFlags queryFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      queryFlags = queryFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) & VULKAN_HPP_NOEXCEPT
    {
      pipelineStatistics = pipelineStatistics_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) && VULKAN_HPP_NOEXCEPT
    {
      pipelineStatistics = pipelineStatistics_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceInfo const *>( this );
    }

    operator VkCommandBufferInheritanceInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceInfo *>( this );
    }

    operator VkCommandBufferInheritanceInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceInfo const *>( this );
    }

    operator VkCommandBufferInheritanceInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               RenderPass const &,
               uint32_t const &,
               Framebuffer const &,
               Bool32 const &,
               QueryControlFlags const &,
               QueryPipelineStatisticFlags const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandBufferInheritanceInfo const & ) const = default;
#else
    bool operator==( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( subpass == rhs.subpass ) &&
             ( framebuffer == rhs.framebuffer ) && ( occlusionQueryEnable == rhs.occlusionQueryEnable ) && ( queryFlags == rhs.queryFlags ) &&
             ( pipelineStatistics == rhs.pipelineStatistics );
#  endif
    }

    bool operator!=( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType               sType                = StructureType::eCommandBufferInheritanceInfo;
    void const *                pNext                = {};
    RenderPass                  renderPass           = {};
    uint32_t                    subpass              = {};
    Framebuffer                 framebuffer          = {};
    Bool32                      occlusionQueryEnable = {};
    QueryControlFlags           queryFlags           = {};
    QueryPipelineStatisticFlags pipelineStatistics   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandBufferInheritanceInfo>
  {
    using Type = CommandBufferInheritanceInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandBufferInheritanceInfo>
  {
    using Type = CommandBufferInheritanceInfo;
  };

  // wrapper struct for struct VkCommandBufferBeginInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferBeginInfo.html
  struct CommandBufferBeginInfo
  {
    using NativeType = VkCommandBufferBeginInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandBufferBeginInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( CommandBufferUsageFlags              flags_            = {},
                                                 CommandBufferInheritanceInfo const * pInheritanceInfo_ = {},
                                                 void const *                         pNext_            = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , pInheritanceInfo{ pInheritanceInfo_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandBufferBeginInfo( *reinterpret_cast<CommandBufferBeginInfo const *>( &rhs ) )
    {
    }

    CommandBufferBeginInfo & operator=( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandBufferBeginInfo & operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandBufferBeginInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo & setFlags( CommandBufferUsageFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo && setFlags( CommandBufferUsageFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo & setPInheritanceInfo( CommandBufferInheritanceInfo const * pInheritanceInfo_ ) & VULKAN_HPP_NOEXCEPT
    {
      pInheritanceInfo = pInheritanceInfo_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo && setPInheritanceInfo( CommandBufferInheritanceInfo const * pInheritanceInfo_ ) && VULKAN_HPP_NOEXCEPT
    {
      pInheritanceInfo = pInheritanceInfo_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferBeginInfo const *>( this );
    }

    operator VkCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferBeginInfo *>( this );
    }

    operator VkCommandBufferBeginInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferBeginInfo const *>( this );
    }

    operator VkCommandBufferBeginInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferBeginInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, CommandBufferUsageFlags const &, CommandBufferInheritanceInfo const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, pInheritanceInfo );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandBufferBeginInfo const & ) const = default;
#else
    bool operator==( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pInheritanceInfo == rhs.pInheritanceInfo );
#  endif
    }

    bool operator!=( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                        sType            = StructureType::eCommandBufferBeginInfo;
    void const *                         pNext            = {};
    CommandBufferUsageFlags              flags            = {};
    CommandBufferInheritanceInfo const * pInheritanceInfo = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandBufferBeginInfo>
  {
    using Type = CommandBufferBeginInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandBufferBeginInfo>
  {
    using Type = CommandBufferBeginInfo;
  };

  // wrapper struct for struct VkCommandBufferInheritanceConditionalRenderingInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html
  struct CommandBufferInheritanceConditionalRenderingInfoEXT
  {
    using NativeType = VkCommandBufferInheritanceConditionalRenderingInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( Bool32       conditionalRenderingEnable_ = {},
                                                                              void const * pNext_                      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , conditionalRenderingEnable{ conditionalRenderingEnable_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      CommandBufferInheritanceConditionalRenderingInfoEXT( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandBufferInheritanceConditionalRenderingInfoEXT( *reinterpret_cast<CommandBufferInheritanceConditionalRenderingInfoEXT const *>( &rhs ) )
    {
    }

    CommandBufferInheritanceConditionalRenderingInfoEXT &
      operator=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandBufferInheritanceConditionalRenderingInfoEXT & operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandBufferInheritanceConditionalRenderingInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      conditionalRenderingEnable = conditionalRenderingEnable_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT && setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      conditionalRenderingEnable = conditionalRenderingEnable_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT const *>( this );
    }

    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT *>( this );
    }

    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT const *>( this );
    }

    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, conditionalRenderingEnable );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const & ) const = default;
#else
    bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRenderingEnable == rhs.conditionalRenderingEnable );
#  endif
    }

    bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                      = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
    void const *  pNext                      = {};
    Bool32        conditionalRenderingEnable = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandBufferInheritanceConditionalRenderingInfoEXT>
  {
    using Type = CommandBufferInheritanceConditionalRenderingInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT>
  {
    using Type = CommandBufferInheritanceConditionalRenderingInfoEXT;
  };

  // wrapper struct for struct VkCommandBufferInheritanceDescriptorHeapInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceDescriptorHeapInfoEXT.html
  struct CommandBufferInheritanceDescriptorHeapInfoEXT
  {
    using NativeType = VkCommandBufferInheritanceDescriptorHeapInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceDescriptorHeapInfoEXT( BindHeapInfoEXT const * pSamplerHeapBindInfo_  = {},
                                                                        BindHeapInfoEXT const * pResourceHeapBindInfo_ = {},
                                                                        void const *            pNext_                 = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pSamplerHeapBindInfo{ pSamplerHeapBindInfo_ }
      , pResourceHeapBindInfo{ pResourceHeapBindInfo_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      CommandBufferInheritanceDescriptorHeapInfoEXT( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandBufferInheritanceDescriptorHeapInfoEXT( VkCommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandBufferInheritanceDescriptorHeapInfoEXT( *reinterpret_cast<CommandBufferInheritanceDescriptorHeapInfoEXT const *>( &rhs ) )
    {
    }

    CommandBufferInheritanceDescriptorHeapInfoEXT & operator=( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandBufferInheritanceDescriptorHeapInfoEXT & operator=( VkCommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandBufferInheritanceDescriptorHeapInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT & setPSamplerHeapBindInfo( BindHeapInfoEXT const * pSamplerHeapBindInfo_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pSamplerHeapBindInfo = pSamplerHeapBindInfo_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT && setPSamplerHeapBindInfo( BindHeapInfoEXT const * pSamplerHeapBindInfo_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pSamplerHeapBindInfo = pSamplerHeapBindInfo_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT & setPResourceHeapBindInfo( BindHeapInfoEXT const * pResourceHeapBindInfo_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pResourceHeapBindInfo = pResourceHeapBindInfo_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT && setPResourceHeapBindInfo( BindHeapInfoEXT const * pResourceHeapBindInfo_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pResourceHeapBindInfo = pResourceHeapBindInfo_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandBufferInheritanceDescriptorHeapInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceDescriptorHeapInfoEXT const *>( this );
    }

    operator VkCommandBufferInheritanceDescriptorHeapInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceDescriptorHeapInfoEXT *>( this );
    }

    operator VkCommandBufferInheritanceDescriptorHeapInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceDescriptorHeapInfoEXT const *>( this );
    }

    operator VkCommandBufferInheritanceDescriptorHeapInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceDescriptorHeapInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, BindHeapInfoEXT const * const &, BindHeapInfoEXT const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pSamplerHeapBindInfo, pResourceHeapBindInfo );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandBufferInheritanceDescriptorHeapInfoEXT const & ) const = default;
#else
    bool operator==( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSamplerHeapBindInfo == rhs.pSamplerHeapBindInfo ) &&
             ( pResourceHeapBindInfo == rhs.pResourceHeapBindInfo );
#  endif
    }

    bool operator!=( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType           sType                 = StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT;
    void const *            pNext                 = {};
    BindHeapInfoEXT const * pSamplerHeapBindInfo  = {};
    BindHeapInfoEXT const * pResourceHeapBindInfo = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandBufferInheritanceDescriptorHeapInfoEXT>
  {
    using Type = CommandBufferInheritanceDescriptorHeapInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT>
  {
    using Type = CommandBufferInheritanceDescriptorHeapInfoEXT;
  };

  // wrapper struct for struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html
  struct CommandBufferInheritanceRenderPassTransformInfoQCOM
  {
    using NativeType = VkCommandBufferInheritanceRenderPassTransformInfoQCOM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderPassTransformInfoQCOM( SurfaceTransformFlagBitsKHR transform_  = SurfaceTransformFlagBitsKHR::eIdentity,
                                                                              Rect2D                      renderArea_ = {},
                                                                              void const *                pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , transform{ transform_ }
      , renderArea{ renderArea_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      CommandBufferInheritanceRenderPassTransformInfoQCOM( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandBufferInheritanceRenderPassTransformInfoQCOM( VkCommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandBufferInheritanceRenderPassTransformInfoQCOM( *reinterpret_cast<CommandBufferInheritanceRenderPassTransformInfoQCOM const *>( &rhs ) )
    {
    }

    CommandBufferInheritanceRenderPassTransformInfoQCOM &
      operator=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandBufferInheritanceRenderPassTransformInfoQCOM & operator=( VkCommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandBufferInheritanceRenderPassTransformInfoQCOM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT
    {
      transform = transform_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT
    {
      transform = transform_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM & setRenderArea( Rect2D const & renderArea_ ) & VULKAN_HPP_NOEXCEPT
    {
      renderArea = renderArea_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM && setRenderArea( Rect2D const & renderArea_ ) && VULKAN_HPP_NOEXCEPT
    {
      renderArea = renderArea_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM const *>( this );
    }

    operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>( this );
    }

    operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM const *>( this );
    }

    operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, SurfaceTransformFlagBitsKHR const &, Rect2D const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, transform, renderArea );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const & ) const = default;
#else
    bool operator==( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) && ( renderArea == rhs.renderArea );
#  endif
    }

    bool operator!=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType               sType      = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM;
    void const *                pNext      = {};
    SurfaceTransformFlagBitsKHR transform  = SurfaceTransformFlagBitsKHR::eIdentity;
    Rect2D                      renderArea = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandBufferInheritanceRenderPassTransformInfoQCOM>
  {
    using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM>
  {
    using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM;
  };

  // wrapper struct for struct VkCommandBufferInheritanceRenderingInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceRenderingInfo.html
  struct CommandBufferInheritanceRenderingInfo
  {
    using NativeType = VkCommandBufferInheritanceRenderingInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandBufferInheritanceRenderingInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderingInfo( RenderingFlags      flags_                   = {},
                                                                uint32_t            viewMask_                = {},
                                                                uint32_t            colorAttachmentCount_    = {},
                                                                Format const *      pColorAttachmentFormats_ = {},
                                                                Format              depthAttachmentFormat_   = Format::eUndefined,
                                                                Format              stencilAttachmentFormat_ = Format::eUndefined,
                                                                SampleCountFlagBits rasterizationSamples_    = SampleCountFlagBits::e1,
                                                                void const *        pNext_                   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , viewMask{ viewMask_ }
      , colorAttachmentCount{ colorAttachmentCount_ }
      , pColorAttachmentFormats{ pColorAttachmentFormats_ }
      , depthAttachmentFormat{ depthAttachmentFormat_ }
      , stencilAttachmentFormat{ stencilAttachmentFormat_ }
      , rasterizationSamples{ rasterizationSamples_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderingInfo( CommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandBufferInheritanceRenderingInfo( VkCommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandBufferInheritanceRenderingInfo( *reinterpret_cast<CommandBufferInheritanceRenderingInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CommandBufferInheritanceRenderingInfo( RenderingFlags                                flags_,
                                           uint32_t                                      viewMask_,
                                           ArrayProxyNoTemporaries<Format const> const & colorAttachmentFormats_,
                                           Format                                        depthAttachmentFormat_   = Format::eUndefined,
                                           Format                                        stencilAttachmentFormat_ = Format::eUndefined,
                                           SampleCountFlagBits                           rasterizationSamples_    = SampleCountFlagBits::e1,
                                           void const *                                  pNext_                   = nullptr )
      : pNext( pNext_ )
      , flags( flags_ )
      , viewMask( viewMask_ )
      , colorAttachmentCount( static_cast<uint32_t>( colorAttachmentFormats_.size() ) )
      , pColorAttachmentFormats( colorAttachmentFormats_.data() )
      , depthAttachmentFormat( depthAttachmentFormat_ )
      , stencilAttachmentFormat( stencilAttachmentFormat_ )
      , rasterizationSamples( rasterizationSamples_ )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CommandBufferInheritanceRenderingInfo & operator=( CommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandBufferInheritanceRenderingInfo & operator=( VkCommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandBufferInheritanceRenderingInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setFlags( RenderingFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setFlags( RenderingFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      viewMask = viewMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      viewMask = viewMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      colorAttachmentCount = colorAttachmentCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      colorAttachmentCount = colorAttachmentCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setPColorAttachmentFormats( Format const * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT
    {
      pColorAttachmentFormats = pColorAttachmentFormats_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setPColorAttachmentFormats( Format const * pColorAttachmentFormats_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pColorAttachmentFormats = pColorAttachmentFormats_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CommandBufferInheritanceRenderingInfo &
      setColorAttachmentFormats( ArrayProxyNoTemporaries<Format const> const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT
    {
      colorAttachmentCount    = static_cast<uint32_t>( colorAttachmentFormats_.size() );
      pColorAttachmentFormats = colorAttachmentFormats_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthAttachmentFormat = depthAttachmentFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthAttachmentFormat = depthAttachmentFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencilAttachmentFormat = stencilAttachmentFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencilAttachmentFormat = stencilAttachmentFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) & VULKAN_HPP_NOEXCEPT
    {
      rasterizationSamples = rasterizationSamples_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) && VULKAN_HPP_NOEXCEPT
    {
      rasterizationSamples = rasterizationSamples_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandBufferInheritanceRenderingInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceRenderingInfo const *>( this );
    }

    operator VkCommandBufferInheritanceRenderingInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceRenderingInfo *>( this );
    }

    operator VkCommandBufferInheritanceRenderingInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceRenderingInfo const *>( this );
    }

    operator VkCommandBufferInheritanceRenderingInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceRenderingInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               RenderingFlags const &,
               uint32_t const &,
               uint32_t const &,
               Format const * const &,
               Format const &,
               Format const &,
               SampleCountFlagBits const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie(
        sType, pNext, flags, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat, rasterizationSamples );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandBufferInheritanceRenderingInfo const & ) const = default;
#else
    bool operator==( CommandBufferInheritanceRenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewMask == rhs.viewMask ) &&
             ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) &&
             ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ) &&
             ( rasterizationSamples == rhs.rasterizationSamples );
#  endif
    }

    bool operator!=( CommandBufferInheritanceRenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType       sType                   = StructureType::eCommandBufferInheritanceRenderingInfo;
    void const *        pNext                   = {};
    RenderingFlags      flags                   = {};
    uint32_t            viewMask                = {};
    uint32_t            colorAttachmentCount    = {};
    Format const *      pColorAttachmentFormats = {};
    Format              depthAttachmentFormat   = Format::eUndefined;
    Format              stencilAttachmentFormat = Format::eUndefined;
    SampleCountFlagBits rasterizationSamples    = SampleCountFlagBits::e1;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandBufferInheritanceRenderingInfo>
  {
    using Type = CommandBufferInheritanceRenderingInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandBufferInheritanceRenderingInfo>
  {
    using Type = CommandBufferInheritanceRenderingInfo;
  };

  using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;

  // wrapper struct for struct VkViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewport.html
  struct Viewport
  {
    using NativeType = VkViewport;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      Viewport( float x_ = {}, float y_ = {}, float width_ = {}, float height_ = {}, float minDepth_ = {}, float maxDepth_ = {} ) VULKAN_HPP_NOEXCEPT
      : x{ x_ }
      , y{ y_ }
      , width{ width_ }
      , height{ height_ }
      , minDepth{ minDepth_ }
      , maxDepth{ maxDepth_ }
    {
    }

    VULKAN_HPP_CONSTEXPR Viewport( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT : Viewport( *reinterpret_cast<Viewport const *>( &rhs ) ) {}

    Viewport & operator=( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    Viewport & operator=( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<Viewport const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 Viewport & setX( float x_ ) & VULKAN_HPP_NOEXCEPT
    {
      x = x_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport && setX( float x_ ) && VULKAN_HPP_NOEXCEPT
    {
      x = x_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport & setY( float y_ ) & VULKAN_HPP_NOEXCEPT
    {
      y = y_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport && setY( float y_ ) && VULKAN_HPP_NOEXCEPT
    {
      y = y_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport & setWidth( float width_ ) & VULKAN_HPP_NOEXCEPT
    {
      width = width_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport && setWidth( float width_ ) && VULKAN_HPP_NOEXCEPT
    {
      width = width_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport & setHeight( float height_ ) & VULKAN_HPP_NOEXCEPT
    {
      height = height_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport && setHeight( float height_ ) && VULKAN_HPP_NOEXCEPT
    {
      height = height_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport & setMinDepth( float minDepth_ ) & VULKAN_HPP_NOEXCEPT
    {
      minDepth = minDepth_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport && setMinDepth( float minDepth_ ) && VULKAN_HPP_NOEXCEPT
    {
      minDepth = minDepth_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport & setMaxDepth( float maxDepth_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxDepth = maxDepth_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 Viewport && setMaxDepth( float maxDepth_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxDepth = maxDepth_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkViewport const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkViewport const *>( this );
    }

    operator VkViewport &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkViewport *>( this );
    }

    operator VkViewport const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkViewport const *>( this );
    }

    operator VkViewport *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkViewport *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<float const &, float const &, float const &, float const &, float const &, float const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( x, y, width, height, minDepth, maxDepth );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( Viewport const & ) const = default;
#else
    bool operator==( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( x == rhs.x ) && ( y == rhs.y ) && ( width == rhs.width ) && ( height == rhs.height ) && ( minDepth == rhs.minDepth ) &&
             ( maxDepth == rhs.maxDepth );
#  endif
    }

    bool operator!=( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    float x        = {};
    float y        = {};
    float width    = {};
    float height   = {};
    float minDepth = {};
    float maxDepth = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkViewport>
  {
    using Type = Viewport;
  };
#endif

  // wrapper struct for struct VkCommandBufferInheritanceViewportScissorInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html
  struct CommandBufferInheritanceViewportScissorInfoNV
  {
    using NativeType = VkCommandBufferInheritanceViewportScissorInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandBufferInheritanceViewportScissorInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CommandBufferInheritanceViewportScissorInfoNV( Bool32           viewportScissor2D_  = {},
                                                                        uint32_t         viewportDepthCount_ = {},
                                                                        Viewport const * pViewportDepths_    = {},
                                                                        void const *     pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , viewportScissor2D{ viewportScissor2D_ }
      , viewportDepthCount{ viewportDepthCount_ }
      , pViewportDepths{ pViewportDepths_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      CommandBufferInheritanceViewportScissorInfoNV( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandBufferInheritanceViewportScissorInfoNV( VkCommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandBufferInheritanceViewportScissorInfoNV( *reinterpret_cast<CommandBufferInheritanceViewportScissorInfoNV const *>( &rhs ) )
    {
    }

    CommandBufferInheritanceViewportScissorInfoNV & operator=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandBufferInheritanceViewportScissorInfoNV & operator=( VkCommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandBufferInheritanceViewportScissorInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setViewportScissor2D( Bool32 viewportScissor2D_ ) & VULKAN_HPP_NOEXCEPT
    {
      viewportScissor2D = viewportScissor2D_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setViewportScissor2D( Bool32 viewportScissor2D_ ) && VULKAN_HPP_NOEXCEPT
    {
      viewportScissor2D = viewportScissor2D_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setViewportDepthCount( uint32_t viewportDepthCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      viewportDepthCount = viewportDepthCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setViewportDepthCount( uint32_t viewportDepthCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      viewportDepthCount = viewportDepthCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setPViewportDepths( Viewport const * pViewportDepths_ ) & VULKAN_HPP_NOEXCEPT
    {
      pViewportDepths = pViewportDepths_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setPViewportDepths( Viewport const * pViewportDepths_ ) && VULKAN_HPP_NOEXCEPT
    {
      pViewportDepths = pViewportDepths_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV const *>( this );
    }

    operator VkCommandBufferInheritanceViewportScissorInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV *>( this );
    }

    operator VkCommandBufferInheritanceViewportScissorInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV const *>( this );
    }

    operator VkCommandBufferInheritanceViewportScissorInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &, uint32_t const &, Viewport const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandBufferInheritanceViewportScissorInfoNV const & ) const = default;
#else
    bool operator==( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) &&
             ( viewportDepthCount == rhs.viewportDepthCount ) && ( pViewportDepths == rhs.pViewportDepths );
#  endif
    }

    bool operator!=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType              = StructureType::eCommandBufferInheritanceViewportScissorInfoNV;
    void const *     pNext              = {};
    Bool32           viewportScissor2D  = {};
    uint32_t         viewportDepthCount = {};
    Viewport const * pViewportDepths    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandBufferInheritanceViewportScissorInfoNV>
  {
    using Type = CommandBufferInheritanceViewportScissorInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandBufferInheritanceViewportScissorInfoNV>
  {
    using Type = CommandBufferInheritanceViewportScissorInfoNV;
  };

  // wrapper struct for struct VkCommandBufferSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferSubmitInfo.html
  struct CommandBufferSubmitInfo
  {
    using NativeType = VkCommandBufferSubmitInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandBufferSubmitInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      CommandBufferSubmitInfo( CommandBuffer commandBuffer_ = {}, uint32_t deviceMask_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , commandBuffer{ commandBuffer_ }
      , deviceMask{ deviceMask_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CommandBufferSubmitInfo( CommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandBufferSubmitInfo( VkCommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandBufferSubmitInfo( *reinterpret_cast<CommandBufferSubmitInfo const *>( &rhs ) )
    {
    }

    CommandBufferSubmitInfo & operator=( CommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandBufferSubmitInfo & operator=( VkCommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandBufferSubmitInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo & setCommandBuffer( CommandBuffer commandBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      commandBuffer = commandBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo && setCommandBuffer( CommandBuffer commandBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      commandBuffer = commandBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceMask = deviceMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceMask = deviceMask_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandBufferSubmitInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferSubmitInfo const *>( this );
    }

    operator VkCommandBufferSubmitInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandBufferSubmitInfo *>( this );
    }

    operator VkCommandBufferSubmitInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferSubmitInfo const *>( this );
    }

    operator VkCommandBufferSubmitInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandBufferSubmitInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, CommandBuffer const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, commandBuffer, deviceMask );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandBufferSubmitInfo const & ) const = default;
#else
    bool operator==( CommandBufferSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) && ( deviceMask == rhs.deviceMask );
#  endif
    }

    bool operator!=( CommandBufferSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType         = StructureType::eCommandBufferSubmitInfo;
    void const *  pNext         = {};
    CommandBuffer commandBuffer = {};
    uint32_t      deviceMask    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandBufferSubmitInfo>
  {
    using Type = CommandBufferSubmitInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandBufferSubmitInfo>
  {
    using Type = CommandBufferSubmitInfo;
  };

  using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;

  // wrapper struct for struct VkCommandPoolCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolCreateInfo.html
  struct CommandPoolCreateInfo
  {
    using NativeType = VkCommandPoolCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCommandPoolCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = {}, uint32_t queueFamilyIndex_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , queueFamilyIndex{ queueFamilyIndex_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : CommandPoolCreateInfo( *reinterpret_cast<CommandPoolCreateInfo const *>( &rhs ) )
    {
    }

    CommandPoolCreateInfo & operator=( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CommandPoolCreateInfo & operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CommandPoolCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo & setFlags( CommandPoolCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo && setFlags( CommandPoolCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      queueFamilyIndex = queueFamilyIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      queueFamilyIndex = queueFamilyIndex_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandPoolCreateInfo const *>( this );
    }

    operator VkCommandPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCommandPoolCreateInfo *>( this );
    }

    operator VkCommandPoolCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandPoolCreateInfo const *>( this );
    }

    operator VkCommandPoolCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCommandPoolCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, CommandPoolCreateFlags const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, queueFamilyIndex );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CommandPoolCreateInfo const & ) const = default;
#else
    bool operator==( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex );
#  endif
    }

    bool operator!=( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType            = StructureType::eCommandPoolCreateInfo;
    void const *           pNext            = {};
    CommandPoolCreateFlags flags            = {};
    uint32_t               queueFamilyIndex = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCommandPoolCreateInfo>
  {
    using Type = CommandPoolCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCommandPoolCreateInfo>
  {
    using Type = CommandPoolCreateInfo;
  };

  // wrapper struct for struct VkComputeOccupancyPriorityParametersNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkComputeOccupancyPriorityParametersNV.html
  struct ComputeOccupancyPriorityParametersNV
  {
    using NativeType = VkComputeOccupancyPriorityParametersNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eComputeOccupancyPriorityParametersNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      ComputeOccupancyPriorityParametersNV( float occupancyPriority_ = {}, float occupancyThrottling_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , occupancyPriority{ occupancyPriority_ }
      , occupancyThrottling{ occupancyThrottling_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ComputeOccupancyPriorityParametersNV( ComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ComputeOccupancyPriorityParametersNV( VkComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ComputeOccupancyPriorityParametersNV( *reinterpret_cast<ComputeOccupancyPriorityParametersNV const *>( &rhs ) )
    {
    }

    ComputeOccupancyPriorityParametersNV & operator=( ComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ComputeOccupancyPriorityParametersNV & operator=( VkComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ComputeOccupancyPriorityParametersNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV & setOccupancyPriority( float occupancyPriority_ ) & VULKAN_HPP_NOEXCEPT
    {
      occupancyPriority = occupancyPriority_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV && setOccupancyPriority( float occupancyPriority_ ) && VULKAN_HPP_NOEXCEPT
    {
      occupancyPriority = occupancyPriority_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV & setOccupancyThrottling( float occupancyThrottling_ ) & VULKAN_HPP_NOEXCEPT
    {
      occupancyThrottling = occupancyThrottling_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV && setOccupancyThrottling( float occupancyThrottling_ ) && VULKAN_HPP_NOEXCEPT
    {
      occupancyThrottling = occupancyThrottling_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkComputeOccupancyPriorityParametersNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkComputeOccupancyPriorityParametersNV const *>( this );
    }

    operator VkComputeOccupancyPriorityParametersNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkComputeOccupancyPriorityParametersNV *>( this );
    }

    operator VkComputeOccupancyPriorityParametersNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkComputeOccupancyPriorityParametersNV const *>( this );
    }

    operator VkComputeOccupancyPriorityParametersNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkComputeOccupancyPriorityParametersNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, float const &, float const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, occupancyPriority, occupancyThrottling );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ComputeOccupancyPriorityParametersNV const & ) const = default;
#else
    bool operator==( ComputeOccupancyPriorityParametersNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( occupancyPriority == rhs.occupancyPriority ) &&
             ( occupancyThrottling == rhs.occupancyThrottling );
#  endif
    }

    bool operator!=( ComputeOccupancyPriorityParametersNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType               = StructureType::eComputeOccupancyPriorityParametersNV;
    void const *  pNext               = {};
    float         occupancyPriority   = {};
    float         occupancyThrottling = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkComputeOccupancyPriorityParametersNV>
  {
    using Type = ComputeOccupancyPriorityParametersNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eComputeOccupancyPriorityParametersNV>
  {
    using Type = ComputeOccupancyPriorityParametersNV;
  };

  // wrapper struct for struct VkSpecializationMapEntry, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpecializationMapEntry.html
  struct SpecializationMapEntry
  {
    using NativeType = VkSpecializationMapEntry;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SpecializationMapEntry( uint32_t constantID_ = {}, uint32_t offset_ = {}, size_t size_ = {} ) VULKAN_HPP_NOEXCEPT
      : constantID{ constantID_ }
      , offset{ offset_ }
      , size{ size_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SpecializationMapEntry( SpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
      : SpecializationMapEntry( *reinterpret_cast<SpecializationMapEntry const *>( &rhs ) )
    {
    }

    SpecializationMapEntry & operator=( SpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SpecializationMapEntry & operator=( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SpecializationMapEntry const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry & setConstantID( uint32_t constantID_ ) & VULKAN_HPP_NOEXCEPT
    {
      constantID = constantID_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry && setConstantID( uint32_t constantID_ ) && VULKAN_HPP_NOEXCEPT
    {
      constantID = constantID_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry & setSize( size_t size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry && setSize( size_t size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSpecializationMapEntry const *>( this );
    }

    operator VkSpecializationMapEntry &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSpecializationMapEntry *>( this );
    }

    operator VkSpecializationMapEntry const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSpecializationMapEntry const *>( this );
    }

    operator VkSpecializationMapEntry *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSpecializationMapEntry *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, size_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( constantID, offset, size );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SpecializationMapEntry const & ) const = default;
#else
    bool operator==( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( constantID == rhs.constantID ) && ( offset == rhs.offset ) && ( size == rhs.size );
#  endif
    }

    bool operator!=( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t constantID = {};
    uint32_t offset     = {};
    size_t   size       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSpecializationMapEntry>
  {
    using Type = SpecializationMapEntry;
  };
#endif

  // wrapper struct for struct VkSpecializationInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpecializationInfo.html
  struct SpecializationInfo
  {
    using NativeType = VkSpecializationInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SpecializationInfo( uint32_t                       mapEntryCount_ = {},
                                             SpecializationMapEntry const * pMapEntries_   = {},
                                             size_t                         dataSize_      = {},
                                             void const *                   pData_         = {} ) VULKAN_HPP_NOEXCEPT
      : mapEntryCount{ mapEntryCount_ }
      , pMapEntries{ pMapEntries_ }
      , dataSize{ dataSize_ }
      , pData{ pData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SpecializationInfo( SpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SpecializationInfo( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SpecializationInfo( *reinterpret_cast<SpecializationInfo const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    SpecializationInfo( ArrayProxyNoTemporaries<SpecializationMapEntry const> const & mapEntries_, ArrayProxyNoTemporaries<T const> const & data_ = {} )
      : mapEntryCount( static_cast<uint32_t>( mapEntries_.size() ) )
      , pMapEntries( mapEntries_.data() )
      , dataSize( data_.size() * sizeof( T ) )
      , pData( data_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    SpecializationInfo & operator=( SpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SpecializationInfo & operator=( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SpecializationInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setMapEntryCount( uint32_t mapEntryCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      mapEntryCount = mapEntryCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setMapEntryCount( uint32_t mapEntryCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      mapEntryCount = mapEntryCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setPMapEntries( SpecializationMapEntry const * pMapEntries_ ) & VULKAN_HPP_NOEXCEPT
    {
      pMapEntries = pMapEntries_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setPMapEntries( SpecializationMapEntry const * pMapEntries_ ) && VULKAN_HPP_NOEXCEPT
    {
      pMapEntries = pMapEntries_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    SpecializationInfo & setMapEntries( ArrayProxyNoTemporaries<SpecializationMapEntry const> const & mapEntries_ ) VULKAN_HPP_NOEXCEPT
    {
      mapEntryCount = static_cast<uint32_t>( mapEntries_.size() );
      pMapEntries   = mapEntries_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setPData( void const * pData_ ) & VULKAN_HPP_NOEXCEPT
    {
      pData = pData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setPData( void const * pData_ ) && VULKAN_HPP_NOEXCEPT
    {
      pData = pData_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    SpecializationInfo & setData( ArrayProxyNoTemporaries<T const> const & data_ ) VULKAN_HPP_NOEXCEPT
    {
      dataSize = data_.size() * sizeof( T );
      pData    = data_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSpecializationInfo const *>( this );
    }

    operator VkSpecializationInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSpecializationInfo *>( this );
    }

    operator VkSpecializationInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSpecializationInfo const *>( this );
    }

    operator VkSpecializationInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSpecializationInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, SpecializationMapEntry const * const &, size_t const &, void const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( mapEntryCount, pMapEntries, dataSize, pData );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SpecializationInfo const & ) const = default;
#else
    bool operator==( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( mapEntryCount == rhs.mapEntryCount ) && ( pMapEntries == rhs.pMapEntries ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
#  endif
    }

    bool operator!=( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t                       mapEntryCount = {};
    SpecializationMapEntry const * pMapEntries   = {};
    size_t                         dataSize      = {};
    void const *                   pData         = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSpecializationInfo>
  {
    using Type = SpecializationInfo;
  };
#endif

  // wrapper struct for struct VkPipelineShaderStageCreateInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateInfo.html
  struct PipelineShaderStageCreateInfo
  {
    using NativeType = VkPipelineShaderStageCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePipelineShaderStageCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_               = {},
                                                        ShaderStageFlagBits            stage_               = ShaderStageFlagBits::eVertex,
                                                        ShaderModule                   module_              = {},
                                                        char const *                   pName_               = {},
                                                        SpecializationInfo const *     pSpecializationInfo_ = {},
                                                        void const *                   pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , stage{ stage_ }
      , module{ module_ }
      , pName{ pName_ }
      , pSpecializationInfo{ pSpecializationInfo_ }
    {
    }

    VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : PipelineShaderStageCreateInfo( *reinterpret_cast<PipelineShaderStageCreateInfo const *>( &rhs ) )
    {
    }

    PipelineShaderStageCreateInfo & operator=( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    PipelineShaderStageCreateInfo & operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<PipelineShaderStageCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setFlags( PipelineShaderStageCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setFlags( PipelineShaderStageCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setStage( ShaderStageFlagBits stage_ ) & VULKAN_HPP_NOEXCEPT
    {
      stage = stage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setStage( ShaderStageFlagBits stage_ ) && VULKAN_HPP_NOEXCEPT
    {
      stage = stage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setModule( ShaderModule module_ ) & VULKAN_HPP_NOEXCEPT
    {
      module = module_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setModule( ShaderModule module_ ) && VULKAN_HPP_NOEXCEPT
    {
      module = module_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setPName( char const * pName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pName = pName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setPName( char const * pName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pName = pName_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setPSpecializationInfo( SpecializationInfo const * pSpecializationInfo_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSpecializationInfo = pSpecializationInfo_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setPSpecializationInfo( SpecializationInfo const * pSpecializationInfo_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSpecializationInfo = pSpecializationInfo_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkPipelineShaderStageCreateInfo const *>( this );
    }

    operator VkPipelineShaderStageCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkPipelineShaderStageCreateInfo *>( this );
    }

    operator VkPipelineShaderStageCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkPipelineShaderStageCreateInfo const *>( this );
    }

    operator VkPipelineShaderStageCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkPipelineShaderStageCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               PipelineShaderStageCreateFlags const &,
               ShaderStageFlagBits const &,
               ShaderModule const &,
               char const * const &,
               SpecializationInfo const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( auto cmp = flags <=> rhs.flags; cmp != 0 )
        return cmp;
      if ( auto cmp = stage <=> rhs.stage; cmp != 0 )
        return cmp;
      if ( auto cmp = module <=> rhs.module; cmp != 0 )
        return cmp;
      if ( pName != rhs.pName )
        if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
      if ( auto cmp = pSpecializationInfo <=> rhs.pSpecializationInfo; cmp != 0 )
        return cmp;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( module == rhs.module ) &&
             ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( pSpecializationInfo == rhs.pSpecializationInfo );
    }

    bool operator!=( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType                  sType               = StructureType::ePipelineShaderStageCreateInfo;
    void const *                   pNext               = {};
    PipelineShaderStageCreateFlags flags               = {};
    ShaderStageFlagBits            stage               = ShaderStageFlagBits::eVertex;
    ShaderModule                   module              = {};
    char const *                   pName               = {};
    SpecializationInfo const *     pSpecializationInfo = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkPipelineShaderStageCreateInfo>
  {
    using Type = PipelineShaderStageCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::ePipelineShaderStageCreateInfo>
  {
    using Type = PipelineShaderStageCreateInfo;
  };

  // wrapper struct for struct VkComputePipelineCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComputePipelineCreateInfo.html
  struct ComputePipelineCreateInfo
  {
    using NativeType = VkComputePipelineCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eComputePipelineCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( PipelineCreateFlags           flags_              = {},
                                                    PipelineShaderStageCreateInfo stage_              = {},
                                                    PipelineLayout                layout_             = {},
                                                    Pipeline                      basePipelineHandle_ = {},
                                                    int32_t                       basePipelineIndex_  = {},
                                                    void const *                  pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , stage{ stage_ }
      , layout{ layout_ }
      , basePipelineHandle{ basePipelineHandle_ }
      , basePipelineIndex{ basePipelineIndex_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : ComputePipelineCreateInfo( *reinterpret_cast<ComputePipelineCreateInfo const *>( &rhs ) )
    {
    }

    ComputePipelineCreateInfo & operator=( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ComputePipelineCreateInfo & operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ComputePipelineCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setStage( PipelineShaderStageCreateInfo const & stage_ ) & VULKAN_HPP_NOEXCEPT
    {
      stage = stage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setStage( PipelineShaderStageCreateInfo const & stage_ ) && VULKAN_HPP_NOEXCEPT
    {
      stage = stage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT
    {
      basePipelineHandle = basePipelineHandle_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT
    {
      basePipelineHandle = basePipelineHandle_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      basePipelineIndex = basePipelineIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      basePipelineIndex = basePipelineIndex_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkComputePipelineCreateInfo const *>( this );
    }

    operator VkComputePipelineCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkComputePipelineCreateInfo *>( this );
    }

    operator VkComputePipelineCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkComputePipelineCreateInfo const *>( this );
    }

    operator VkComputePipelineCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkComputePipelineCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               PipelineCreateFlags const &,
               PipelineShaderStageCreateInfo const &,
               PipelineLayout const &,
               Pipeline const &,
               int32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ComputePipelineCreateInfo const & ) const = default;
#else
    bool operator==( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( layout == rhs.layout ) &&
             ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex );
#  endif
    }

    bool operator!=( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                 sType              = StructureType::eComputePipelineCreateInfo;
    void const *                  pNext              = {};
    PipelineCreateFlags           flags              = {};
    PipelineShaderStageCreateInfo stage              = {};
    PipelineLayout                layout             = {};
    Pipeline                      basePipelineHandle = {};
    int32_t                       basePipelineIndex  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkComputePipelineCreateInfo>
  {
    using Type = ComputePipelineCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eComputePipelineCreateInfo>
  {
    using Type = ComputePipelineCreateInfo;
  };

  // wrapper struct for struct VkComputePipelineIndirectBufferInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkComputePipelineIndirectBufferInfoNV.html
  struct ComputePipelineIndirectBufferInfoNV
  {
    using NativeType = VkComputePipelineIndirectBufferInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eComputePipelineIndirectBufferInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ComputePipelineIndirectBufferInfoNV( DeviceAddress deviceAddress_                      = {},
                                                              DeviceSize    size_                               = {},
                                                              DeviceAddress pipelineDeviceAddressCaptureReplay_ = {},
                                                              void const *  pNext_                              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , deviceAddress{ deviceAddress_ }
      , size{ size_ }
      , pipelineDeviceAddressCaptureReplay{ pipelineDeviceAddressCaptureReplay_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ComputePipelineIndirectBufferInfoNV( ComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ComputePipelineIndirectBufferInfoNV( VkComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ComputePipelineIndirectBufferInfoNV( *reinterpret_cast<ComputePipelineIndirectBufferInfoNV const *>( &rhs ) )
    {
    }

    ComputePipelineIndirectBufferInfoNV & operator=( ComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ComputePipelineIndirectBufferInfoNV & operator=( VkComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ComputePipelineIndirectBufferInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      deviceAddress = deviceAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setPipelineDeviceAddressCaptureReplay( DeviceAddress pipelineDeviceAddressCaptureReplay_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pipelineDeviceAddressCaptureReplay = pipelineDeviceAddressCaptureReplay_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setPipelineDeviceAddressCaptureReplay( DeviceAddress pipelineDeviceAddressCaptureReplay_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pipelineDeviceAddressCaptureReplay = pipelineDeviceAddressCaptureReplay_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkComputePipelineIndirectBufferInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkComputePipelineIndirectBufferInfoNV const *>( this );
    }

    operator VkComputePipelineIndirectBufferInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkComputePipelineIndirectBufferInfoNV *>( this );
    }

    operator VkComputePipelineIndirectBufferInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkComputePipelineIndirectBufferInfoNV const *>( this );
    }

    operator VkComputePipelineIndirectBufferInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkComputePipelineIndirectBufferInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceAddress const &, DeviceSize const &, DeviceAddress const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, deviceAddress, size, pipelineDeviceAddressCaptureReplay );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ComputePipelineIndirectBufferInfoNV const & ) const = default;
#else
    bool operator==( ComputePipelineIndirectBufferInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && ( size == rhs.size ) &&
             ( pipelineDeviceAddressCaptureReplay == rhs.pipelineDeviceAddressCaptureReplay );
#  endif
    }

    bool operator!=( ComputePipelineIndirectBufferInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                              = StructureType::eComputePipelineIndirectBufferInfoNV;
    void const *  pNext                              = {};
    DeviceAddress deviceAddress                      = {};
    DeviceSize    size                               = {};
    DeviceAddress pipelineDeviceAddressCaptureReplay = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkComputePipelineIndirectBufferInfoNV>
  {
    using Type = ComputePipelineIndirectBufferInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eComputePipelineIndirectBufferInfoNV>
  {
    using Type = ComputePipelineIndirectBufferInfoNV;
  };

  // wrapper struct for struct VkConditionalRenderingBeginInfo2EXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingBeginInfo2EXT.html
  struct ConditionalRenderingBeginInfo2EXT
  {
    using NativeType = VkConditionalRenderingBeginInfo2EXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eConditionalRenderingBeginInfo2EXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfo2EXT( DeviceAddressRangeKHR        addressRange_ = {},
                                                            AddressCommandFlagsKHR       addressFlags_ = {},
                                                            ConditionalRenderingFlagsEXT flags_        = {},
                                                            void const *                 pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , addressRange{ addressRange_ }
      , addressFlags{ addressFlags_ }
      , flags{ flags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfo2EXT( ConditionalRenderingBeginInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ConditionalRenderingBeginInfo2EXT( VkConditionalRenderingBeginInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : ConditionalRenderingBeginInfo2EXT( *reinterpret_cast<ConditionalRenderingBeginInfo2EXT const *>( &rhs ) )
    {
    }

    ConditionalRenderingBeginInfo2EXT & operator=( ConditionalRenderingBeginInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ConditionalRenderingBeginInfo2EXT & operator=( VkConditionalRenderingBeginInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ConditionalRenderingBeginInfo2EXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT & setFlags( ConditionalRenderingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT && setFlags( ConditionalRenderingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkConditionalRenderingBeginInfo2EXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkConditionalRenderingBeginInfo2EXT const *>( this );
    }

    operator VkConditionalRenderingBeginInfo2EXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkConditionalRenderingBeginInfo2EXT *>( this );
    }

    operator VkConditionalRenderingBeginInfo2EXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkConditionalRenderingBeginInfo2EXT const *>( this );
    }

    operator VkConditionalRenderingBeginInfo2EXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkConditionalRenderingBeginInfo2EXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceAddressRangeKHR const &, AddressCommandFlagsKHR const &, ConditionalRenderingFlagsEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, addressRange, addressFlags, flags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ConditionalRenderingBeginInfo2EXT const & ) const = default;
#else
    bool operator==( ConditionalRenderingBeginInfo2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ) &&
             ( flags == rhs.flags );
#  endif
    }

    bool operator!=( ConditionalRenderingBeginInfo2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                sType        = StructureType::eConditionalRenderingBeginInfo2EXT;
    void const *                 pNext        = {};
    DeviceAddressRangeKHR        addressRange = {};
    AddressCommandFlagsKHR       addressFlags = {};
    ConditionalRenderingFlagsEXT flags        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkConditionalRenderingBeginInfo2EXT>
  {
    using Type = ConditionalRenderingBeginInfo2EXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eConditionalRenderingBeginInfo2EXT>
  {
    using Type = ConditionalRenderingBeginInfo2EXT;
  };

  // wrapper struct for struct VkConditionalRenderingBeginInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingBeginInfoEXT.html
  struct ConditionalRenderingBeginInfoEXT
  {
    using NativeType = VkConditionalRenderingBeginInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eConditionalRenderingBeginInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( Buffer                       buffer_ = {},
                                                           DeviceSize                   offset_ = {},
                                                           ConditionalRenderingFlagsEXT flags_  = {},
                                                           void const *                 pNext_  = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , buffer{ buffer_ }
      , offset{ offset_ }
      , flags{ flags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : ConditionalRenderingBeginInfoEXT( *reinterpret_cast<ConditionalRenderingBeginInfoEXT const *>( &rhs ) )
    {
    }

    ConditionalRenderingBeginInfoEXT & operator=( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ConditionalRenderingBeginInfoEXT & operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ConditionalRenderingBeginInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setFlags( ConditionalRenderingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setFlags( ConditionalRenderingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT const *>( this );
    }

    operator VkConditionalRenderingBeginInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT *>( this );
    }

    operator VkConditionalRenderingBeginInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkConditionalRenderingBeginInfoEXT const *>( this );
    }

    operator VkConditionalRenderingBeginInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkConditionalRenderingBeginInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Buffer const &, DeviceSize const &, ConditionalRenderingFlagsEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, buffer, offset, flags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ConditionalRenderingBeginInfoEXT const & ) const = default;
#else
    bool operator==( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( flags == rhs.flags );
#  endif
    }

    bool operator!=( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                sType  = StructureType::eConditionalRenderingBeginInfoEXT;
    void const *                 pNext  = {};
    Buffer                       buffer = {};
    DeviceSize                   offset = {};
    ConditionalRenderingFlagsEXT flags  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkConditionalRenderingBeginInfoEXT>
  {
    using Type = ConditionalRenderingBeginInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eConditionalRenderingBeginInfoEXT>
  {
    using Type = ConditionalRenderingBeginInfoEXT;
  };

  // wrapper struct for struct VkConformanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkConformanceVersion.html
  struct ConformanceVersion
  {
    using NativeType = VkConformanceVersion;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ConformanceVersion( uint8_t major_ = {}, uint8_t minor_ = {}, uint8_t subminor_ = {}, uint8_t patch_ = {} ) VULKAN_HPP_NOEXCEPT
      : major{ major_ }
      , minor{ minor_ }
      , subminor{ subminor_ }
      , patch{ patch_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ConformanceVersion( ConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ConformanceVersion( VkConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT : ConformanceVersion( *reinterpret_cast<ConformanceVersion const *>( &rhs ) ) {}

    ConformanceVersion & operator=( ConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ConformanceVersion & operator=( VkConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ConformanceVersion const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setMajor( uint8_t major_ ) & VULKAN_HPP_NOEXCEPT
    {
      major = major_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setMajor( uint8_t major_ ) && VULKAN_HPP_NOEXCEPT
    {
      major = major_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setMinor( uint8_t minor_ ) & VULKAN_HPP_NOEXCEPT
    {
      minor = minor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setMinor( uint8_t minor_ ) && VULKAN_HPP_NOEXCEPT
    {
      minor = minor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setSubminor( uint8_t subminor_ ) & VULKAN_HPP_NOEXCEPT
    {
      subminor = subminor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setSubminor( uint8_t subminor_ ) && VULKAN_HPP_NOEXCEPT
    {
      subminor = subminor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setPatch( uint8_t patch_ ) & VULKAN_HPP_NOEXCEPT
    {
      patch = patch_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setPatch( uint8_t patch_ ) && VULKAN_HPP_NOEXCEPT
    {
      patch = patch_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkConformanceVersion const *>( this );
    }

    operator VkConformanceVersion &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkConformanceVersion *>( this );
    }

    operator VkConformanceVersion const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkConformanceVersion const *>( this );
    }

    operator VkConformanceVersion *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkConformanceVersion *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint8_t const &, uint8_t const &, uint8_t const &, uint8_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( major, minor, subminor, patch );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ConformanceVersion const & ) const = default;
#else
    bool operator==( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( major == rhs.major ) && ( minor == rhs.minor ) && ( subminor == rhs.subminor ) && ( patch == rhs.patch );
#  endif
    }

    bool operator!=( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint8_t major    = {};
    uint8_t minor    = {};
    uint8_t subminor = {};
    uint8_t patch    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkConformanceVersion>
  {
    using Type = ConformanceVersion;
  };
#endif
  using ConformanceVersionKHR = ConformanceVersion;

  // wrapper struct for struct VkConvertCooperativeVectorMatrixInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConvertCooperativeVectorMatrixInfoNV.html
  struct ConvertCooperativeVectorMatrixInfoNV
  {
    using NativeType = VkConvertCooperativeVectorMatrixInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eConvertCooperativeVectorMatrixInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV( size_t                          srcSize_          = {},
                                                                  DeviceOrHostAddressConstKHR     srcData_          = {},
                                                                  size_t *                        pDstSize_         = {},
                                                                  DeviceOrHostAddressKHR          dstData_          = {},
                                                                  ComponentTypeKHR                srcComponentType_ = ComponentTypeKHR::eFloat16,
                                                                  ComponentTypeKHR                dstComponentType_ = ComponentTypeKHR::eFloat16,
                                                                  uint32_t                        numRows_          = {},
                                                                  uint32_t                        numColumns_       = {},
                                                                  CooperativeVectorMatrixLayoutNV srcLayout_ = CooperativeVectorMatrixLayoutNV::eRowMajor,
                                                                  size_t                          srcStride_ = {},
                                                                  CooperativeVectorMatrixLayoutNV dstLayout_ = CooperativeVectorMatrixLayoutNV::eRowMajor,
                                                                  size_t                          dstStride_ = {},
                                                                  void const *                    pNext_     = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcSize{ srcSize_ }
      , srcData{ srcData_ }
      , pDstSize{ pDstSize_ }
      , dstData{ dstData_ }
      , srcComponentType{ srcComponentType_ }
      , dstComponentType{ dstComponentType_ }
      , numRows{ numRows_ }
      , numColumns{ numColumns_ }
      , srcLayout{ srcLayout_ }
      , srcStride{ srcStride_ }
      , dstLayout{ dstLayout_ }
      , dstStride{ dstStride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV( ConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ConvertCooperativeVectorMatrixInfoNV( VkConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : ConvertCooperativeVectorMatrixInfoNV( *reinterpret_cast<ConvertCooperativeVectorMatrixInfoNV const *>( &rhs ) )
    {
    }

    ConvertCooperativeVectorMatrixInfoNV & operator=( ConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ConvertCooperativeVectorMatrixInfoNV & operator=( VkConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ConvertCooperativeVectorMatrixInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcSize( size_t srcSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcSize = srcSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcSize( size_t srcSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcSize = srcSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcData( DeviceOrHostAddressConstKHR const & srcData_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcData = srcData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcData( DeviceOrHostAddressConstKHR const & srcData_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcData = srcData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setPDstSize( size_t * pDstSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      pDstSize = pDstSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setPDstSize( size_t * pDstSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      pDstSize = pDstSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstData( DeviceOrHostAddressKHR const & dstData_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstData = dstData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstData( DeviceOrHostAddressKHR const & dstData_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstData = dstData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcComponentType( ComponentTypeKHR srcComponentType_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcComponentType = srcComponentType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcComponentType( ComponentTypeKHR srcComponentType_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcComponentType = srcComponentType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstComponentType( ComponentTypeKHR dstComponentType_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstComponentType = dstComponentType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstComponentType( ComponentTypeKHR dstComponentType_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstComponentType = dstComponentType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setNumRows( uint32_t numRows_ ) & VULKAN_HPP_NOEXCEPT
    {
      numRows = numRows_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setNumRows( uint32_t numRows_ ) && VULKAN_HPP_NOEXCEPT
    {
      numRows = numRows_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setNumColumns( uint32_t numColumns_ ) & VULKAN_HPP_NOEXCEPT
    {
      numColumns = numColumns_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setNumColumns( uint32_t numColumns_ ) && VULKAN_HPP_NOEXCEPT
    {
      numColumns = numColumns_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcLayout( CooperativeVectorMatrixLayoutNV srcLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcLayout = srcLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcLayout( CooperativeVectorMatrixLayoutNV srcLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcLayout = srcLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcStride( size_t srcStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcStride = srcStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcStride( size_t srcStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcStride = srcStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstLayout( CooperativeVectorMatrixLayoutNV dstLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstLayout = dstLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstLayout( CooperativeVectorMatrixLayoutNV dstLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstLayout = dstLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstStride( size_t dstStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstStride = dstStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstStride( size_t dstStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstStride = dstStride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkConvertCooperativeVectorMatrixInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkConvertCooperativeVectorMatrixInfoNV const *>( this );
    }

    operator VkConvertCooperativeVectorMatrixInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkConvertCooperativeVectorMatrixInfoNV *>( this );
    }

    operator VkConvertCooperativeVectorMatrixInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkConvertCooperativeVectorMatrixInfoNV const *>( this );
    }

    operator VkConvertCooperativeVectorMatrixInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkConvertCooperativeVectorMatrixInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               size_t const &,
               DeviceOrHostAddressConstKHR const &,
               size_t * const &,
               DeviceOrHostAddressKHR const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               uint32_t const &,
               uint32_t const &,
               CooperativeVectorMatrixLayoutNV const &,
               size_t const &,
               CooperativeVectorMatrixLayoutNV const &,
               size_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       srcSize,
                       srcData,
                       pDstSize,
                       dstData,
                       srcComponentType,
                       dstComponentType,
                       numRows,
                       numColumns,
                       srcLayout,
                       srcStride,
                       dstLayout,
                       dstStride );
    }
#endif

  public:
    StructureType                   sType            = StructureType::eConvertCooperativeVectorMatrixInfoNV;
    void const *                    pNext            = {};
    size_t                          srcSize          = {};
    DeviceOrHostAddressConstKHR     srcData          = {};
    size_t *                        pDstSize         = {};
    DeviceOrHostAddressKHR          dstData          = {};
    ComponentTypeKHR                srcComponentType = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR                dstComponentType = ComponentTypeKHR::eFloat16;
    uint32_t                        numRows          = {};
    uint32_t                        numColumns       = {};
    CooperativeVectorMatrixLayoutNV srcLayout        = CooperativeVectorMatrixLayoutNV::eRowMajor;
    size_t                          srcStride        = {};
    CooperativeVectorMatrixLayoutNV dstLayout        = CooperativeVectorMatrixLayoutNV::eRowMajor;
    size_t                          dstStride        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkConvertCooperativeVectorMatrixInfoNV>
  {
    using Type = ConvertCooperativeVectorMatrixInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eConvertCooperativeVectorMatrixInfoNV>
  {
    using Type = ConvertCooperativeVectorMatrixInfoNV;
  };

  // wrapper struct for struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixFlexibleDimensionsPropertiesNV.html
  struct CooperativeMatrixFlexibleDimensionsPropertiesNV
  {
    using NativeType = VkCooperativeMatrixFlexibleDimensionsPropertiesNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CooperativeMatrixFlexibleDimensionsPropertiesNV( uint32_t         MGranularity_           = {},
                                                                          uint32_t         NGranularity_           = {},
                                                                          uint32_t         KGranularity_           = {},
                                                                          ComponentTypeKHR AType_                  = ComponentTypeKHR::eFloat16,
                                                                          ComponentTypeKHR BType_                  = ComponentTypeKHR::eFloat16,
                                                                          ComponentTypeKHR CType_                  = ComponentTypeKHR::eFloat16,
                                                                          ComponentTypeKHR ResultType_             = ComponentTypeKHR::eFloat16,
                                                                          Bool32           saturatingAccumulation_ = {},
                                                                          ScopeKHR         scope_                  = ScopeKHR::eDevice,
                                                                          uint32_t         workgroupInvocations_   = {},
                                                                          void *           pNext_                  = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , MGranularity{ MGranularity_ }
      , NGranularity{ NGranularity_ }
      , KGranularity{ KGranularity_ }
      , AType{ AType_ }
      , BType{ BType_ }
      , CType{ CType_ }
      , ResultType{ ResultType_ }
      , saturatingAccumulation{ saturatingAccumulation_ }
      , scope{ scope_ }
      , workgroupInvocations{ workgroupInvocations_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      CooperativeMatrixFlexibleDimensionsPropertiesNV( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CooperativeMatrixFlexibleDimensionsPropertiesNV( VkCooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : CooperativeMatrixFlexibleDimensionsPropertiesNV( *reinterpret_cast<CooperativeMatrixFlexibleDimensionsPropertiesNV const *>( &rhs ) )
    {
    }

    CooperativeMatrixFlexibleDimensionsPropertiesNV & operator=( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CooperativeMatrixFlexibleDimensionsPropertiesNV & operator=( VkCooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CooperativeMatrixFlexibleDimensionsPropertiesNV const *>( &rhs );
      return *this;
    }

    operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV const *>( this );
    }

    operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV *>( this );
    }

    operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV const *>( this );
    }

    operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               Bool32 const &,
               ScopeKHR const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie(
        sType, pNext, MGranularity, NGranularity, KGranularity, AType, BType, CType, ResultType, saturatingAccumulation, scope, workgroupInvocations );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CooperativeMatrixFlexibleDimensionsPropertiesNV const & ) const = default;
#else
    bool operator==( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MGranularity == rhs.MGranularity ) && ( NGranularity == rhs.NGranularity ) &&
             ( KGranularity == rhs.KGranularity ) && ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) &&
             ( ResultType == rhs.ResultType ) && ( saturatingAccumulation == rhs.saturatingAccumulation ) && ( scope == rhs.scope ) &&
             ( workgroupInvocations == rhs.workgroupInvocations );
#  endif
    }

    bool operator!=( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType                  = StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV;
    void *           pNext                  = {};
    uint32_t         MGranularity           = {};
    uint32_t         NGranularity           = {};
    uint32_t         KGranularity           = {};
    ComponentTypeKHR AType                  = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR BType                  = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR CType                  = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR ResultType             = ComponentTypeKHR::eFloat16;
    Bool32           saturatingAccumulation = {};
    ScopeKHR         scope                  = ScopeKHR::eDevice;
    uint32_t         workgroupInvocations   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCooperativeMatrixFlexibleDimensionsPropertiesNV>
  {
    using Type = CooperativeMatrixFlexibleDimensionsPropertiesNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV>
  {
    using Type = CooperativeMatrixFlexibleDimensionsPropertiesNV;
  };

  // wrapper struct for struct VkCooperativeMatrixPropertiesKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixPropertiesKHR.html
  struct CooperativeMatrixPropertiesKHR
  {
    using NativeType = VkCooperativeMatrixPropertiesKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCooperativeMatrixPropertiesKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesKHR( uint32_t         MSize_                  = {},
                                                         uint32_t         NSize_                  = {},
                                                         uint32_t         KSize_                  = {},
                                                         ComponentTypeKHR AType_                  = ComponentTypeKHR::eFloat16,
                                                         ComponentTypeKHR BType_                  = ComponentTypeKHR::eFloat16,
                                                         ComponentTypeKHR CType_                  = ComponentTypeKHR::eFloat16,
                                                         ComponentTypeKHR ResultType_             = ComponentTypeKHR::eFloat16,
                                                         Bool32           saturatingAccumulation_ = {},
                                                         ScopeKHR         scope_                  = ScopeKHR::eDevice,
                                                         void *           pNext_                  = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , MSize{ MSize_ }
      , NSize{ NSize_ }
      , KSize{ KSize_ }
      , AType{ AType_ }
      , BType{ BType_ }
      , CType{ CType_ }
      , ResultType{ ResultType_ }
      , saturatingAccumulation{ saturatingAccumulation_ }
      , scope{ scope_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CooperativeMatrixPropertiesKHR( VkCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CooperativeMatrixPropertiesKHR( *reinterpret_cast<CooperativeMatrixPropertiesKHR const *>( &rhs ) )
    {
    }

    CooperativeMatrixPropertiesKHR & operator=( CooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CooperativeMatrixPropertiesKHR & operator=( VkCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CooperativeMatrixPropertiesKHR const *>( &rhs );
      return *this;
    }

    operator VkCooperativeMatrixPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCooperativeMatrixPropertiesKHR const *>( this );
    }

    operator VkCooperativeMatrixPropertiesKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( this );
    }

    operator VkCooperativeMatrixPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCooperativeMatrixPropertiesKHR const *>( this );
    }

    operator VkCooperativeMatrixPropertiesKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               Bool32 const &,
               ScopeKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, ResultType, saturatingAccumulation, scope );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CooperativeMatrixPropertiesKHR const & ) const = default;
#else
    bool operator==( CooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && ( KSize == rhs.KSize ) &&
             ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && ( ResultType == rhs.ResultType ) &&
             ( saturatingAccumulation == rhs.saturatingAccumulation ) && ( scope == rhs.scope );
#  endif
    }

    bool operator!=( CooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType                  = StructureType::eCooperativeMatrixPropertiesKHR;
    void *           pNext                  = {};
    uint32_t         MSize                  = {};
    uint32_t         NSize                  = {};
    uint32_t         KSize                  = {};
    ComponentTypeKHR AType                  = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR BType                  = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR CType                  = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR ResultType             = ComponentTypeKHR::eFloat16;
    Bool32           saturatingAccumulation = {};
    ScopeKHR         scope                  = ScopeKHR::eDevice;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCooperativeMatrixPropertiesKHR>
  {
    using Type = CooperativeMatrixPropertiesKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCooperativeMatrixPropertiesKHR>
  {
    using Type = CooperativeMatrixPropertiesKHR;
  };

  // wrapper struct for struct VkCooperativeMatrixPropertiesNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixPropertiesNV.html
  struct CooperativeMatrixPropertiesNV
  {
    using NativeType = VkCooperativeMatrixPropertiesNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCooperativeMatrixPropertiesNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t        MSize_ = {},
                                                        uint32_t        NSize_ = {},
                                                        uint32_t        KSize_ = {},
                                                        ComponentTypeNV AType_ = {},
                                                        ComponentTypeNV BType_ = {},
                                                        ComponentTypeNV CType_ = {},
                                                        ComponentTypeNV DType_ = {},
                                                        ScopeNV         scope_ = {},
                                                        void *          pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , MSize{ MSize_ }
      , NSize{ NSize_ }
      , KSize{ KSize_ }
      , AType{ AType_ }
      , BType{ BType_ }
      , CType{ CType_ }
      , DType{ DType_ }
      , scope{ scope_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : CooperativeMatrixPropertiesNV( *reinterpret_cast<CooperativeMatrixPropertiesNV const *>( &rhs ) )
    {
    }

    CooperativeMatrixPropertiesNV & operator=( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CooperativeMatrixPropertiesNV & operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CooperativeMatrixPropertiesNV const *>( &rhs );
      return *this;
    }

    operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCooperativeMatrixPropertiesNV const *>( this );
    }

    operator VkCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( this );
    }

    operator VkCooperativeMatrixPropertiesNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCooperativeMatrixPropertiesNV const *>( this );
    }

    operator VkCooperativeMatrixPropertiesNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               ComponentTypeNV const &,
               ComponentTypeNV const &,
               ComponentTypeNV const &,
               ComponentTypeNV const &,
               ScopeNV const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CooperativeMatrixPropertiesNV const & ) const = default;
#else
    bool operator==( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && ( KSize == rhs.KSize ) &&
             ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && ( DType == rhs.DType ) && ( scope == rhs.scope );
#  endif
    }

    bool operator!=( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType   sType = StructureType::eCooperativeMatrixPropertiesNV;
    void *          pNext = {};
    uint32_t        MSize = {};
    uint32_t        NSize = {};
    uint32_t        KSize = {};
    ComponentTypeNV AType = {};
    ComponentTypeNV BType = {};
    ComponentTypeNV CType = {};
    ComponentTypeNV DType = {};
    ScopeNV         scope = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCooperativeMatrixPropertiesNV>
  {
    using Type = CooperativeMatrixPropertiesNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCooperativeMatrixPropertiesNV>
  {
    using Type = CooperativeMatrixPropertiesNV;
  };

  // wrapper struct for struct VkCooperativeVectorPropertiesNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeVectorPropertiesNV.html
  struct CooperativeVectorPropertiesNV
  {
    using NativeType = VkCooperativeVectorPropertiesNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCooperativeVectorPropertiesNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CooperativeVectorPropertiesNV( ComponentTypeKHR inputType_            = ComponentTypeKHR::eFloat16,
                                                        ComponentTypeKHR inputInterpretation_  = ComponentTypeKHR::eFloat16,
                                                        ComponentTypeKHR matrixInterpretation_ = ComponentTypeKHR::eFloat16,
                                                        ComponentTypeKHR biasInterpretation_   = ComponentTypeKHR::eFloat16,
                                                        ComponentTypeKHR resultType_           = ComponentTypeKHR::eFloat16,
                                                        Bool32           transpose_            = {},
                                                        void *           pNext_                = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , inputType{ inputType_ }
      , inputInterpretation{ inputInterpretation_ }
      , matrixInterpretation{ matrixInterpretation_ }
      , biasInterpretation{ biasInterpretation_ }
      , resultType{ resultType_ }
      , transpose{ transpose_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CooperativeVectorPropertiesNV( CooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CooperativeVectorPropertiesNV( VkCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : CooperativeVectorPropertiesNV( *reinterpret_cast<CooperativeVectorPropertiesNV const *>( &rhs ) )
    {
    }

    CooperativeVectorPropertiesNV & operator=( CooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CooperativeVectorPropertiesNV & operator=( VkCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CooperativeVectorPropertiesNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setInputType( ComponentTypeKHR inputType_ ) & VULKAN_HPP_NOEXCEPT
    {
      inputType = inputType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setInputType( ComponentTypeKHR inputType_ ) && VULKAN_HPP_NOEXCEPT
    {
      inputType = inputType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setInputInterpretation( ComponentTypeKHR inputInterpretation_ ) & VULKAN_HPP_NOEXCEPT
    {
      inputInterpretation = inputInterpretation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setInputInterpretation( ComponentTypeKHR inputInterpretation_ ) && VULKAN_HPP_NOEXCEPT
    {
      inputInterpretation = inputInterpretation_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setMatrixInterpretation( ComponentTypeKHR matrixInterpretation_ ) & VULKAN_HPP_NOEXCEPT
    {
      matrixInterpretation = matrixInterpretation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setMatrixInterpretation( ComponentTypeKHR matrixInterpretation_ ) && VULKAN_HPP_NOEXCEPT
    {
      matrixInterpretation = matrixInterpretation_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setBiasInterpretation( ComponentTypeKHR biasInterpretation_ ) & VULKAN_HPP_NOEXCEPT
    {
      biasInterpretation = biasInterpretation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setBiasInterpretation( ComponentTypeKHR biasInterpretation_ ) && VULKAN_HPP_NOEXCEPT
    {
      biasInterpretation = biasInterpretation_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setResultType( ComponentTypeKHR resultType_ ) & VULKAN_HPP_NOEXCEPT
    {
      resultType = resultType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setResultType( ComponentTypeKHR resultType_ ) && VULKAN_HPP_NOEXCEPT
    {
      resultType = resultType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setTranspose( Bool32 transpose_ ) & VULKAN_HPP_NOEXCEPT
    {
      transpose = transpose_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setTranspose( Bool32 transpose_ ) && VULKAN_HPP_NOEXCEPT
    {
      transpose = transpose_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCooperativeVectorPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCooperativeVectorPropertiesNV const *>( this );
    }

    operator VkCooperativeVectorPropertiesNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCooperativeVectorPropertiesNV *>( this );
    }

    operator VkCooperativeVectorPropertiesNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCooperativeVectorPropertiesNV const *>( this );
    }

    operator VkCooperativeVectorPropertiesNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCooperativeVectorPropertiesNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               ComponentTypeKHR const &,
               Bool32 const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, inputType, inputInterpretation, matrixInterpretation, biasInterpretation, resultType, transpose );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CooperativeVectorPropertiesNV const & ) const = default;
#else
    bool operator==( CooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inputType == rhs.inputType ) && ( inputInterpretation == rhs.inputInterpretation ) &&
             ( matrixInterpretation == rhs.matrixInterpretation ) && ( biasInterpretation == rhs.biasInterpretation ) && ( resultType == rhs.resultType ) &&
             ( transpose == rhs.transpose );
#  endif
    }

    bool operator!=( CooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType                = StructureType::eCooperativeVectorPropertiesNV;
    void *           pNext                = {};
    ComponentTypeKHR inputType            = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR inputInterpretation  = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR matrixInterpretation = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR biasInterpretation   = ComponentTypeKHR::eFloat16;
    ComponentTypeKHR resultType           = ComponentTypeKHR::eFloat16;
    Bool32           transpose            = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCooperativeVectorPropertiesNV>
  {
    using Type = CooperativeVectorPropertiesNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCooperativeVectorPropertiesNV>
  {
    using Type = CooperativeVectorPropertiesNV;
  };

  // wrapper struct for struct VkCopyAccelerationStructureInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyAccelerationStructureInfoKHR.html
  struct CopyAccelerationStructureInfoKHR
  {
    using NativeType = VkCopyAccelerationStructureInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyAccelerationStructureInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( AccelerationStructureKHR         src_   = {},
                                                           AccelerationStructureKHR         dst_   = {},
                                                           CopyAccelerationStructureModeKHR mode_  = CopyAccelerationStructureModeKHR::eClone,
                                                           void const *                     pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , src{ src_ }
      , dst{ dst_ }
      , mode{ mode_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyAccelerationStructureInfoKHR( VkCopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyAccelerationStructureInfoKHR( *reinterpret_cast<CopyAccelerationStructureInfoKHR const *>( &rhs ) )
    {
    }

    CopyAccelerationStructureInfoKHR & operator=( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyAccelerationStructureInfoKHR & operator=( VkCopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyAccelerationStructureInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setSrc( AccelerationStructureKHR src_ ) & VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setSrc( AccelerationStructureKHR src_ ) && VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setDst( AccelerationStructureKHR dst_ ) & VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setDst( AccelerationStructureKHR dst_ ) && VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setMode( CopyAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setMode( CopyAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyAccelerationStructureInfoKHR const *>( this );
    }

    operator VkCopyAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyAccelerationStructureInfoKHR *>( this );
    }

    operator VkCopyAccelerationStructureInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyAccelerationStructureInfoKHR const *>( this );
    }

    operator VkCopyAccelerationStructureInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyAccelerationStructureInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AccelerationStructureKHR const &,
               AccelerationStructureKHR const &,
               CopyAccelerationStructureModeKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, src, dst, mode );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyAccelerationStructureInfoKHR const & ) const = default;
#else
    bool operator==( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && ( mode == rhs.mode );
#  endif
    }

    bool operator!=( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                    sType = StructureType::eCopyAccelerationStructureInfoKHR;
    void const *                     pNext = {};
    AccelerationStructureKHR         src   = {};
    AccelerationStructureKHR         dst   = {};
    CopyAccelerationStructureModeKHR mode  = CopyAccelerationStructureModeKHR::eClone;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyAccelerationStructureInfoKHR>
  {
    using Type = CopyAccelerationStructureInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyAccelerationStructureInfoKHR>
  {
    using Type = CopyAccelerationStructureInfoKHR;
  };

  // wrapper struct for struct VkCopyAccelerationStructureToMemoryInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html
  struct CopyAccelerationStructureToMemoryInfoKHR
  {
    using NativeType = VkCopyAccelerationStructureToMemoryInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyAccelerationStructureToMemoryInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR( AccelerationStructureKHR         src_   = {},
                                                                      DeviceOrHostAddressKHR           dst_   = {},
                                                                      CopyAccelerationStructureModeKHR mode_  = CopyAccelerationStructureModeKHR::eClone,
                                                                      void const *                     pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , src{ src_ }
      , dst{ dst_ }
      , mode{ mode_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyAccelerationStructureToMemoryInfoKHR( VkCopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyAccelerationStructureToMemoryInfoKHR( *reinterpret_cast<CopyAccelerationStructureToMemoryInfoKHR const *>( &rhs ) )
    {
    }

    CopyAccelerationStructureToMemoryInfoKHR & operator=( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyAccelerationStructureToMemoryInfoKHR & operator=( VkCopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyAccelerationStructureToMemoryInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setSrc( AccelerationStructureKHR src_ ) & VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setSrc( AccelerationStructureKHR src_ ) && VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setDst( DeviceOrHostAddressKHR const & dst_ ) & VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setDst( DeviceOrHostAddressKHR const & dst_ ) && VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setMode( CopyAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setMode( CopyAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR const *>( this );
    }

    operator VkCopyAccelerationStructureToMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR *>( this );
    }

    operator VkCopyAccelerationStructureToMemoryInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR const *>( this );
    }

    operator VkCopyAccelerationStructureToMemoryInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AccelerationStructureKHR const &,
               DeviceOrHostAddressKHR const &,
               CopyAccelerationStructureModeKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, src, dst, mode );
    }
#endif

  public:
    StructureType                    sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR;
    void const *                     pNext = {};
    AccelerationStructureKHR         src   = {};
    DeviceOrHostAddressKHR           dst   = {};
    CopyAccelerationStructureModeKHR mode  = CopyAccelerationStructureModeKHR::eClone;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyAccelerationStructureToMemoryInfoKHR>
  {
    using Type = CopyAccelerationStructureToMemoryInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyAccelerationStructureToMemoryInfoKHR>
  {
    using Type = CopyAccelerationStructureToMemoryInfoKHR;
  };

  // wrapper struct for struct VkCopyBufferInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyBufferInfo2.html
  struct CopyBufferInfo2
  {
    using NativeType = VkCopyBufferInfo2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyBufferInfo2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyBufferInfo2( Buffer              srcBuffer_   = {},
                                          Buffer              dstBuffer_   = {},
                                          uint32_t            regionCount_ = {},
                                          BufferCopy2 const * pRegions_    = {},
                                          void const *        pNext_       = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcBuffer{ srcBuffer_ }
      , dstBuffer{ dstBuffer_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyBufferInfo2( CopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyBufferInfo2( VkCopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : CopyBufferInfo2( *reinterpret_cast<CopyBufferInfo2 const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyBufferInfo2( Buffer srcBuffer_, Buffer dstBuffer_, ArrayProxyNoTemporaries<BufferCopy2 const> const & regions_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), srcBuffer( srcBuffer_ ), dstBuffer( dstBuffer_ ), regionCount( static_cast<uint32_t>( regions_.size() ) ), pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyBufferInfo2 & operator=( CopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyBufferInfo2 & operator=( VkCopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyBufferInfo2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setSrcBuffer( Buffer srcBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcBuffer = srcBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setSrcBuffer( Buffer srcBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcBuffer = srcBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setDstBuffer( Buffer dstBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstBuffer = dstBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setDstBuffer( Buffer dstBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstBuffer = dstBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setPRegions( BufferCopy2 const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setPRegions( BufferCopy2 const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyBufferInfo2 & setRegions( ArrayProxyNoTemporaries<BufferCopy2 const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyBufferInfo2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyBufferInfo2 const *>( this );
    }

    operator VkCopyBufferInfo2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyBufferInfo2 *>( this );
    }

    operator VkCopyBufferInfo2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyBufferInfo2 const *>( this );
    }

    operator VkCopyBufferInfo2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyBufferInfo2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Buffer const &, Buffer const &, uint32_t const &, BufferCopy2 const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyBufferInfo2 const & ) const = default;
#else
    bool operator==( CopyBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && ( dstBuffer == rhs.dstBuffer ) &&
             ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType       sType       = StructureType::eCopyBufferInfo2;
    void const *        pNext       = {};
    Buffer              srcBuffer   = {};
    Buffer              dstBuffer   = {};
    uint32_t            regionCount = {};
    BufferCopy2 const * pRegions    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyBufferInfo2>
  {
    using Type = CopyBufferInfo2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyBufferInfo2>
  {
    using Type = CopyBufferInfo2;
  };

  using CopyBufferInfo2KHR = CopyBufferInfo2;

  // wrapper struct for struct VkCopyBufferToImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyBufferToImageInfo2.html
  struct CopyBufferToImageInfo2
  {
    using NativeType = VkCopyBufferToImageInfo2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyBufferToImageInfo2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyBufferToImageInfo2( Buffer                   srcBuffer_      = {},
                                                 Image                    dstImage_       = {},
                                                 ImageLayout              dstImageLayout_ = ImageLayout::eUndefined,
                                                 uint32_t                 regionCount_    = {},
                                                 BufferImageCopy2 const * pRegions_       = {},
                                                 void const *             pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcBuffer{ srcBuffer_ }
      , dstImage{ dstImage_ }
      , dstImageLayout{ dstImageLayout_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyBufferToImageInfo2( CopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyBufferToImageInfo2( VkCopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyBufferToImageInfo2( *reinterpret_cast<CopyBufferToImageInfo2 const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyBufferToImageInfo2( Buffer                                                  srcBuffer_,
                            Image                                                   dstImage_,
                            ImageLayout                                             dstImageLayout_,
                            ArrayProxyNoTemporaries<BufferImageCopy2 const> const & regions_,
                            void const *                                            pNext_ = nullptr )
      : pNext( pNext_ )
      , srcBuffer( srcBuffer_ )
      , dstImage( dstImage_ )
      , dstImageLayout( dstImageLayout_ )
      , regionCount( static_cast<uint32_t>( regions_.size() ) )
      , pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyBufferToImageInfo2 & operator=( CopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyBufferToImageInfo2 & operator=( VkCopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyBufferToImageInfo2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setSrcBuffer( Buffer srcBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcBuffer = srcBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setSrcBuffer( Buffer srcBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcBuffer = srcBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setPRegions( BufferImageCopy2 const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setPRegions( BufferImageCopy2 const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyBufferToImageInfo2 & setRegions( ArrayProxyNoTemporaries<BufferImageCopy2 const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyBufferToImageInfo2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyBufferToImageInfo2 const *>( this );
    }

    operator VkCopyBufferToImageInfo2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyBufferToImageInfo2 *>( this );
    }

    operator VkCopyBufferToImageInfo2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyBufferToImageInfo2 const *>( this );
    }

    operator VkCopyBufferToImageInfo2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyBufferToImageInfo2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::
      tuple<StructureType const &, void const * const &, Buffer const &, Image const &, ImageLayout const &, uint32_t const &, BufferImageCopy2 const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyBufferToImageInfo2 const & ) const = default;
#else
    bool operator==( CopyBufferToImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && ( dstImage == rhs.dstImage ) &&
             ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyBufferToImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType            sType          = StructureType::eCopyBufferToImageInfo2;
    void const *             pNext          = {};
    Buffer                   srcBuffer      = {};
    Image                    dstImage       = {};
    ImageLayout              dstImageLayout = ImageLayout::eUndefined;
    uint32_t                 regionCount    = {};
    BufferImageCopy2 const * pRegions       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyBufferToImageInfo2>
  {
    using Type = CopyBufferToImageInfo2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyBufferToImageInfo2>
  {
    using Type = CopyBufferToImageInfo2;
  };

  using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;

  // wrapper struct for struct VkCopyCommandTransformInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyCommandTransformInfoQCOM.html
  struct CopyCommandTransformInfoQCOM
  {
    using NativeType = VkCopyCommandTransformInfoQCOM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyCommandTransformInfoQCOM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyCommandTransformInfoQCOM( SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity,
                                                       void const *                pNext_     = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , transform{ transform_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyCommandTransformInfoQCOM( CopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyCommandTransformInfoQCOM( VkCopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyCommandTransformInfoQCOM( *reinterpret_cast<CopyCommandTransformInfoQCOM const *>( &rhs ) )
    {
    }

    CopyCommandTransformInfoQCOM & operator=( CopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyCommandTransformInfoQCOM & operator=( VkCopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyCommandTransformInfoQCOM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT
    {
      transform = transform_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT
    {
      transform = transform_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyCommandTransformInfoQCOM const *>( this );
    }

    operator VkCopyCommandTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyCommandTransformInfoQCOM *>( this );
    }

    operator VkCopyCommandTransformInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyCommandTransformInfoQCOM const *>( this );
    }

    operator VkCopyCommandTransformInfoQCOM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyCommandTransformInfoQCOM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, SurfaceTransformFlagBitsKHR const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, transform );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyCommandTransformInfoQCOM const & ) const = default;
#else
    bool operator==( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform );
#  endif
    }

    bool operator!=( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType               sType     = StructureType::eCopyCommandTransformInfoQCOM;
    void const *                pNext     = {};
    SurfaceTransformFlagBitsKHR transform = SurfaceTransformFlagBitsKHR::eIdentity;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyCommandTransformInfoQCOM>
  {
    using Type = CopyCommandTransformInfoQCOM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyCommandTransformInfoQCOM>
  {
    using Type = CopyCommandTransformInfoQCOM;
  };

  // wrapper struct for struct VkCopyDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyDescriptorSet.html
  struct CopyDescriptorSet
  {
    using NativeType = VkCopyDescriptorSet;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyDescriptorSet;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyDescriptorSet( DescriptorSet srcSet_          = {},
                                            uint32_t      srcBinding_      = {},
                                            uint32_t      srcArrayElement_ = {},
                                            DescriptorSet dstSet_          = {},
                                            uint32_t      dstBinding_      = {},
                                            uint32_t      dstArrayElement_ = {},
                                            uint32_t      descriptorCount_ = {},
                                            void const *  pNext_           = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcSet{ srcSet_ }
      , srcBinding{ srcBinding_ }
      , srcArrayElement{ srcArrayElement_ }
      , dstSet{ dstSet_ }
      , dstBinding{ dstBinding_ }
      , dstArrayElement{ dstArrayElement_ }
      , descriptorCount{ descriptorCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyDescriptorSet( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT : CopyDescriptorSet( *reinterpret_cast<CopyDescriptorSet const *>( &rhs ) ) {}

    CopyDescriptorSet & operator=( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyDescriptorSet & operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyDescriptorSet const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setSrcSet( DescriptorSet srcSet_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcSet = srcSet_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setSrcSet( DescriptorSet srcSet_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcSet = srcSet_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setSrcBinding( uint32_t srcBinding_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcBinding = srcBinding_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setSrcBinding( uint32_t srcBinding_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcBinding = srcBinding_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setSrcArrayElement( uint32_t srcArrayElement_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcArrayElement = srcArrayElement_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setSrcArrayElement( uint32_t srcArrayElement_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcArrayElement = srcArrayElement_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDstSet( DescriptorSet dstSet_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstSet = dstSet_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDstSet( DescriptorSet dstSet_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstSet = dstSet_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDstBinding( uint32_t dstBinding_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstBinding = dstBinding_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDstBinding( uint32_t dstBinding_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstBinding = dstBinding_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDstArrayElement( uint32_t dstArrayElement_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstArrayElement = dstArrayElement_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDstArrayElement( uint32_t dstArrayElement_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstArrayElement = dstArrayElement_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorCount = descriptorCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorCount = descriptorCount_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyDescriptorSet const *>( this );
    }

    operator VkCopyDescriptorSet &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyDescriptorSet *>( this );
    }

    operator VkCopyDescriptorSet const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyDescriptorSet const *>( this );
    }

    operator VkCopyDescriptorSet *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyDescriptorSet *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DescriptorSet const &,
               uint32_t const &,
               uint32_t const &,
               DescriptorSet const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyDescriptorSet const & ) const = default;
#else
    bool operator==( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSet == rhs.srcSet ) && ( srcBinding == rhs.srcBinding ) &&
             ( srcArrayElement == rhs.srcArrayElement ) && ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) &&
             ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount );
#  endif
    }

    bool operator!=( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType           = StructureType::eCopyDescriptorSet;
    void const *  pNext           = {};
    DescriptorSet srcSet          = {};
    uint32_t      srcBinding      = {};
    uint32_t      srcArrayElement = {};
    DescriptorSet dstSet          = {};
    uint32_t      dstBinding      = {};
    uint32_t      dstArrayElement = {};
    uint32_t      descriptorCount = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyDescriptorSet>
  {
    using Type = CopyDescriptorSet;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyDescriptorSet>
  {
    using Type = CopyDescriptorSet;
  };

  // wrapper struct for struct VkDeviceMemoryImageCopyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryImageCopyKHR.html
  struct DeviceMemoryImageCopyKHR
  {
    using NativeType = VkDeviceMemoryImageCopyKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDeviceMemoryImageCopyKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DeviceMemoryImageCopyKHR( DeviceAddressRangeKHR  addressRange_       = {},
                                                   AddressCommandFlagsKHR addressFlags_       = {},
                                                   uint32_t               addressRowLength_   = {},
                                                   uint32_t               addressImageHeight_ = {},
                                                   ImageSubresourceLayers imageSubresource_   = {},
                                                   ImageLayout            imageLayout_        = ImageLayout::eUndefined,
                                                   Offset3D               imageOffset_        = {},
                                                   Extent3D               imageExtent_        = {},
                                                   void const *           pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , addressRange{ addressRange_ }
      , addressFlags{ addressFlags_ }
      , addressRowLength{ addressRowLength_ }
      , addressImageHeight{ addressImageHeight_ }
      , imageSubresource{ imageSubresource_ }
      , imageLayout{ imageLayout_ }
      , imageOffset{ imageOffset_ }
      , imageExtent{ imageExtent_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DeviceMemoryImageCopyKHR( DeviceMemoryImageCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DeviceMemoryImageCopyKHR( VkDeviceMemoryImageCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : DeviceMemoryImageCopyKHR( *reinterpret_cast<DeviceMemoryImageCopyKHR const *>( &rhs ) )
    {
    }

    DeviceMemoryImageCopyKHR & operator=( DeviceMemoryImageCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DeviceMemoryImageCopyKHR & operator=( VkDeviceMemoryImageCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DeviceMemoryImageCopyKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressRange = addressRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressFlags = addressFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setAddressRowLength( uint32_t addressRowLength_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressRowLength = addressRowLength_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setAddressRowLength( uint32_t addressRowLength_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressRowLength = addressRowLength_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setAddressImageHeight( uint32_t addressImageHeight_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressImageHeight = addressImageHeight_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setAddressImageHeight( uint32_t addressImageHeight_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressImageHeight = addressImageHeight_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageLayout = imageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageLayout = imageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDeviceMemoryImageCopyKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceMemoryImageCopyKHR const *>( this );
    }

    operator VkDeviceMemoryImageCopyKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceMemoryImageCopyKHR *>( this );
    }

    operator VkDeviceMemoryImageCopyKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceMemoryImageCopyKHR const *>( this );
    }

    operator VkDeviceMemoryImageCopyKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceMemoryImageCopyKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DeviceAddressRangeKHR const &,
               AddressCommandFlagsKHR const &,
               uint32_t const &,
               uint32_t const &,
               ImageSubresourceLayers const &,
               ImageLayout const &,
               Offset3D const &,
               Extent3D const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie(
        sType, pNext, addressRange, addressFlags, addressRowLength, addressImageHeight, imageSubresource, imageLayout, imageOffset, imageExtent );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DeviceMemoryImageCopyKHR const & ) const = default;
#else
    bool operator==( DeviceMemoryImageCopyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ) &&
             ( addressRowLength == rhs.addressRowLength ) && ( addressImageHeight == rhs.addressImageHeight ) && ( imageSubresource == rhs.imageSubresource ) &&
             ( imageLayout == rhs.imageLayout ) && ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent );
#  endif
    }

    bool operator!=( DeviceMemoryImageCopyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType              = StructureType::eDeviceMemoryImageCopyKHR;
    void const *           pNext              = {};
    DeviceAddressRangeKHR  addressRange       = {};
    AddressCommandFlagsKHR addressFlags       = {};
    uint32_t               addressRowLength   = {};
    uint32_t               addressImageHeight = {};
    ImageSubresourceLayers imageSubresource   = {};
    ImageLayout            imageLayout        = ImageLayout::eUndefined;
    Offset3D               imageOffset        = {};
    Extent3D               imageExtent        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDeviceMemoryImageCopyKHR>
  {
    using Type = DeviceMemoryImageCopyKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDeviceMemoryImageCopyKHR>
  {
    using Type = DeviceMemoryImageCopyKHR;
  };

  // wrapper struct for struct VkCopyDeviceMemoryImageInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyDeviceMemoryImageInfoKHR.html
  struct CopyDeviceMemoryImageInfoKHR
  {
    using NativeType = VkCopyDeviceMemoryImageInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyDeviceMemoryImageInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyDeviceMemoryImageInfoKHR( Image                            image_       = {},
                                                       uint32_t                         regionCount_ = {},
                                                       DeviceMemoryImageCopyKHR const * pRegions_    = {},
                                                       void const *                     pNext_       = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , image{ image_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyDeviceMemoryImageInfoKHR( CopyDeviceMemoryImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyDeviceMemoryImageInfoKHR( VkCopyDeviceMemoryImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyDeviceMemoryImageInfoKHR( *reinterpret_cast<CopyDeviceMemoryImageInfoKHR const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyDeviceMemoryImageInfoKHR( Image image_, ArrayProxyNoTemporaries<DeviceMemoryImageCopyKHR const> const & regions_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), image( image_ ), regionCount( static_cast<uint32_t>( regions_.size() ) ), pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyDeviceMemoryImageInfoKHR & operator=( CopyDeviceMemoryImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyDeviceMemoryImageInfoKHR & operator=( VkCopyDeviceMemoryImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyDeviceMemoryImageInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR & setPRegions( DeviceMemoryImageCopyKHR const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR && setPRegions( DeviceMemoryImageCopyKHR const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyDeviceMemoryImageInfoKHR & setRegions( ArrayProxyNoTemporaries<DeviceMemoryImageCopyKHR const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyDeviceMemoryImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyDeviceMemoryImageInfoKHR const *>( this );
    }

    operator VkCopyDeviceMemoryImageInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyDeviceMemoryImageInfoKHR *>( this );
    }

    operator VkCopyDeviceMemoryImageInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyDeviceMemoryImageInfoKHR const *>( this );
    }

    operator VkCopyDeviceMemoryImageInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyDeviceMemoryImageInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Image const &, uint32_t const &, DeviceMemoryImageCopyKHR const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, image, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyDeviceMemoryImageInfoKHR const & ) const = default;
#else
    bool operator==( CopyDeviceMemoryImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyDeviceMemoryImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                    sType       = StructureType::eCopyDeviceMemoryImageInfoKHR;
    void const *                     pNext       = {};
    Image                            image       = {};
    uint32_t                         regionCount = {};
    DeviceMemoryImageCopyKHR const * pRegions    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyDeviceMemoryImageInfoKHR>
  {
    using Type = CopyDeviceMemoryImageInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyDeviceMemoryImageInfoKHR>
  {
    using Type = CopyDeviceMemoryImageInfoKHR;
  };

  // wrapper struct for struct VkDeviceMemoryCopyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryCopyKHR.html
  struct DeviceMemoryCopyKHR
  {
    using NativeType = VkDeviceMemoryCopyKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDeviceMemoryCopyKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DeviceMemoryCopyKHR( DeviceAddressRangeKHR  srcRange_ = {},
                                              AddressCommandFlagsKHR srcFlags_ = {},
                                              DeviceAddressRangeKHR  dstRange_ = {},
                                              AddressCommandFlagsKHR dstFlags_ = {},
                                              void const *           pNext_    = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcRange{ srcRange_ }
      , srcFlags{ srcFlags_ }
      , dstRange{ dstRange_ }
      , dstFlags{ dstFlags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DeviceMemoryCopyKHR( DeviceMemoryCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DeviceMemoryCopyKHR( VkDeviceMemoryCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceMemoryCopyKHR( *reinterpret_cast<DeviceMemoryCopyKHR const *>( &rhs ) )
    {
    }

    DeviceMemoryCopyKHR & operator=( DeviceMemoryCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DeviceMemoryCopyKHR & operator=( VkDeviceMemoryCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DeviceMemoryCopyKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setSrcRange( DeviceAddressRangeKHR const & srcRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcRange = srcRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setSrcRange( DeviceAddressRangeKHR const & srcRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcRange = srcRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setSrcFlags( AddressCommandFlagsKHR srcFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcFlags = srcFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setSrcFlags( AddressCommandFlagsKHR srcFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcFlags = srcFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setDstRange( DeviceAddressRangeKHR const & dstRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstRange = dstRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setDstRange( DeviceAddressRangeKHR const & dstRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstRange = dstRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setDstFlags( AddressCommandFlagsKHR dstFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstFlags = dstFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setDstFlags( AddressCommandFlagsKHR dstFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstFlags = dstFlags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDeviceMemoryCopyKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceMemoryCopyKHR const *>( this );
    }

    operator VkDeviceMemoryCopyKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceMemoryCopyKHR *>( this );
    }

    operator VkDeviceMemoryCopyKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceMemoryCopyKHR const *>( this );
    }

    operator VkDeviceMemoryCopyKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceMemoryCopyKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DeviceAddressRangeKHR const &,
               AddressCommandFlagsKHR const &,
               DeviceAddressRangeKHR const &,
               AddressCommandFlagsKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcRange, srcFlags, dstRange, dstFlags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DeviceMemoryCopyKHR const & ) const = default;
#else
    bool operator==( DeviceMemoryCopyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRange == rhs.srcRange ) && ( srcFlags == rhs.srcFlags ) && ( dstRange == rhs.dstRange ) &&
             ( dstFlags == rhs.dstFlags );
#  endif
    }

    bool operator!=( DeviceMemoryCopyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType    = StructureType::eDeviceMemoryCopyKHR;
    void const *           pNext    = {};
    DeviceAddressRangeKHR  srcRange = {};
    AddressCommandFlagsKHR srcFlags = {};
    DeviceAddressRangeKHR  dstRange = {};
    AddressCommandFlagsKHR dstFlags = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDeviceMemoryCopyKHR>
  {
    using Type = DeviceMemoryCopyKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDeviceMemoryCopyKHR>
  {
    using Type = DeviceMemoryCopyKHR;
  };

  // wrapper struct for struct VkCopyDeviceMemoryInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyDeviceMemoryInfoKHR.html
  struct CopyDeviceMemoryInfoKHR
  {
    using NativeType = VkCopyDeviceMemoryInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyDeviceMemoryInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      CopyDeviceMemoryInfoKHR( uint32_t regionCount_ = {}, DeviceMemoryCopyKHR const * pRegions_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyDeviceMemoryInfoKHR( CopyDeviceMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyDeviceMemoryInfoKHR( VkCopyDeviceMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyDeviceMemoryInfoKHR( *reinterpret_cast<CopyDeviceMemoryInfoKHR const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyDeviceMemoryInfoKHR( ArrayProxyNoTemporaries<DeviceMemoryCopyKHR const> const & regions_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), regionCount( static_cast<uint32_t>( regions_.size() ) ), pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyDeviceMemoryInfoKHR & operator=( CopyDeviceMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyDeviceMemoryInfoKHR & operator=( VkCopyDeviceMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyDeviceMemoryInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR & setPRegions( DeviceMemoryCopyKHR const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR && setPRegions( DeviceMemoryCopyKHR const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyDeviceMemoryInfoKHR & setRegions( ArrayProxyNoTemporaries<DeviceMemoryCopyKHR const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyDeviceMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyDeviceMemoryInfoKHR const *>( this );
    }

    operator VkCopyDeviceMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyDeviceMemoryInfoKHR *>( this );
    }

    operator VkCopyDeviceMemoryInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyDeviceMemoryInfoKHR const *>( this );
    }

    operator VkCopyDeviceMemoryInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyDeviceMemoryInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, DeviceMemoryCopyKHR const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyDeviceMemoryInfoKHR const & ) const = default;
#else
    bool operator==( CopyDeviceMemoryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyDeviceMemoryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType               sType       = StructureType::eCopyDeviceMemoryInfoKHR;
    void const *                pNext       = {};
    uint32_t                    regionCount = {};
    DeviceMemoryCopyKHR const * pRegions    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyDeviceMemoryInfoKHR>
  {
    using Type = CopyDeviceMemoryInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyDeviceMemoryInfoKHR>
  {
    using Type = CopyDeviceMemoryInfoKHR;
  };

  // wrapper struct for struct VkImageCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCopy2.html
  struct ImageCopy2
  {
    using NativeType = VkImageCopy2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eImageCopy2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ImageCopy2( ImageSubresourceLayers srcSubresource_ = {},
                                     Offset3D               srcOffset_      = {},
                                     ImageSubresourceLayers dstSubresource_ = {},
                                     Offset3D               dstOffset_      = {},
                                     Extent3D               extent_         = {},
                                     void const *           pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcSubresource{ srcSubresource_ }
      , srcOffset{ srcOffset_ }
      , dstSubresource{ dstSubresource_ }
      , dstOffset{ dstOffset_ }
      , extent{ extent_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ImageCopy2( ImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ImageCopy2( VkImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageCopy2( *reinterpret_cast<ImageCopy2 const *>( &rhs ) ) {}

    ImageCopy2 & operator=( ImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ImageCopy2 & operator=( VkImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ImageCopy2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcSubresource = srcSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcSubresource = srcSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setSrcOffset( Offset3D const & srcOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcOffset = srcOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setSrcOffset( Offset3D const & srcOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcOffset = srcOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstSubresource = dstSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstSubresource = dstSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setDstOffset( Offset3D const & dstOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstOffset = dstOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setDstOffset( Offset3D const & dstOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstOffset = dstOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT
    {
      extent = extent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT
    {
      extent = extent_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkImageCopy2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageCopy2 const *>( this );
    }

    operator VkImageCopy2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageCopy2 *>( this );
    }

    operator VkImageCopy2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageCopy2 const *>( this );
    }

    operator VkImageCopy2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageCopy2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               ImageSubresourceLayers const &,
               Offset3D const &,
               ImageSubresourceLayers const &,
               Offset3D const &,
               Extent3D const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ImageCopy2 const & ) const = default;
#else
    bool operator==( ImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) &&
             ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
#  endif
    }

    bool operator!=( ImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType          = StructureType::eImageCopy2;
    void const *           pNext          = {};
    ImageSubresourceLayers srcSubresource = {};
    Offset3D               srcOffset      = {};
    ImageSubresourceLayers dstSubresource = {};
    Offset3D               dstOffset      = {};
    Extent3D               extent         = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkImageCopy2>
  {
    using Type = ImageCopy2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eImageCopy2>
  {
    using Type = ImageCopy2;
  };

  using ImageCopy2KHR = ImageCopy2;

  // wrapper struct for struct VkCopyImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageInfo2.html
  struct CopyImageInfo2
  {
    using NativeType = VkCopyImageInfo2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyImageInfo2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyImageInfo2( Image              srcImage_       = {},
                                         ImageLayout        srcImageLayout_ = ImageLayout::eUndefined,
                                         Image              dstImage_       = {},
                                         ImageLayout        dstImageLayout_ = ImageLayout::eUndefined,
                                         uint32_t           regionCount_    = {},
                                         ImageCopy2 const * pRegions_       = {},
                                         void const *       pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcImage{ srcImage_ }
      , srcImageLayout{ srcImageLayout_ }
      , dstImage{ dstImage_ }
      , dstImageLayout{ dstImageLayout_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyImageInfo2( CopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyImageInfo2( VkCopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : CopyImageInfo2( *reinterpret_cast<CopyImageInfo2 const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyImageInfo2( Image                                             srcImage_,
                    ImageLayout                                       srcImageLayout_,
                    Image                                             dstImage_,
                    ImageLayout                                       dstImageLayout_,
                    ArrayProxyNoTemporaries<ImageCopy2 const> const & regions_,
                    void const *                                      pNext_ = nullptr )
      : pNext( pNext_ )
      , srcImage( srcImage_ )
      , srcImageLayout( srcImageLayout_ )
      , dstImage( dstImage_ )
      , dstImageLayout( dstImageLayout_ )
      , regionCount( static_cast<uint32_t>( regions_.size() ) )
      , pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyImageInfo2 & operator=( CopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyImageInfo2 & operator=( VkCopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyImageInfo2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setPRegions( ImageCopy2 const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setPRegions( ImageCopy2 const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyImageInfo2 & setRegions( ArrayProxyNoTemporaries<ImageCopy2 const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyImageInfo2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyImageInfo2 const *>( this );
    }

    operator VkCopyImageInfo2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyImageInfo2 *>( this );
    }

    operator VkCopyImageInfo2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyImageInfo2 const *>( this );
    }

    operator VkCopyImageInfo2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyImageInfo2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               Image const &,
               ImageLayout const &,
               Image const &,
               ImageLayout const &,
               uint32_t const &,
               ImageCopy2 const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyImageInfo2 const & ) const = default;
#else
    bool operator==( CopyImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) &&
             ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType      sType          = StructureType::eCopyImageInfo2;
    void const *       pNext          = {};
    Image              srcImage       = {};
    ImageLayout        srcImageLayout = ImageLayout::eUndefined;
    Image              dstImage       = {};
    ImageLayout        dstImageLayout = ImageLayout::eUndefined;
    uint32_t           regionCount    = {};
    ImageCopy2 const * pRegions       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyImageInfo2>
  {
    using Type = CopyImageInfo2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyImageInfo2>
  {
    using Type = CopyImageInfo2;
  };

  using CopyImageInfo2KHR = CopyImageInfo2;

  // wrapper struct for struct VkCopyImageToBufferInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageToBufferInfo2.html
  struct CopyImageToBufferInfo2
  {
    using NativeType = VkCopyImageToBufferInfo2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyImageToBufferInfo2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyImageToBufferInfo2( Image                    srcImage_       = {},
                                                 ImageLayout              srcImageLayout_ = ImageLayout::eUndefined,
                                                 Buffer                   dstBuffer_      = {},
                                                 uint32_t                 regionCount_    = {},
                                                 BufferImageCopy2 const * pRegions_       = {},
                                                 void const *             pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcImage{ srcImage_ }
      , srcImageLayout{ srcImageLayout_ }
      , dstBuffer{ dstBuffer_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyImageToBufferInfo2( CopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyImageToBufferInfo2( VkCopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyImageToBufferInfo2( *reinterpret_cast<CopyImageToBufferInfo2 const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyImageToBufferInfo2( Image                                                   srcImage_,
                            ImageLayout                                             srcImageLayout_,
                            Buffer                                                  dstBuffer_,
                            ArrayProxyNoTemporaries<BufferImageCopy2 const> const & regions_,
                            void const *                                            pNext_ = nullptr )
      : pNext( pNext_ )
      , srcImage( srcImage_ )
      , srcImageLayout( srcImageLayout_ )
      , dstBuffer( dstBuffer_ )
      , regionCount( static_cast<uint32_t>( regions_.size() ) )
      , pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyImageToBufferInfo2 & operator=( CopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyImageToBufferInfo2 & operator=( VkCopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyImageToBufferInfo2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setDstBuffer( Buffer dstBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstBuffer = dstBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setDstBuffer( Buffer dstBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstBuffer = dstBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setPRegions( BufferImageCopy2 const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setPRegions( BufferImageCopy2 const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyImageToBufferInfo2 & setRegions( ArrayProxyNoTemporaries<BufferImageCopy2 const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyImageToBufferInfo2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyImageToBufferInfo2 const *>( this );
    }

    operator VkCopyImageToBufferInfo2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyImageToBufferInfo2 *>( this );
    }

    operator VkCopyImageToBufferInfo2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyImageToBufferInfo2 const *>( this );
    }

    operator VkCopyImageToBufferInfo2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyImageToBufferInfo2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::
      tuple<StructureType const &, void const * const &, Image const &, ImageLayout const &, Buffer const &, uint32_t const &, BufferImageCopy2 const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyImageToBufferInfo2 const & ) const = default;
#else
    bool operator==( CopyImageToBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) &&
             ( dstBuffer == rhs.dstBuffer ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyImageToBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType            sType          = StructureType::eCopyImageToBufferInfo2;
    void const *             pNext          = {};
    Image                    srcImage       = {};
    ImageLayout              srcImageLayout = ImageLayout::eUndefined;
    Buffer                   dstBuffer      = {};
    uint32_t                 regionCount    = {};
    BufferImageCopy2 const * pRegions       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyImageToBufferInfo2>
  {
    using Type = CopyImageToBufferInfo2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyImageToBufferInfo2>
  {
    using Type = CopyImageToBufferInfo2;
  };

  using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;

  // wrapper struct for struct VkCopyImageToImageInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageToImageInfo.html
  struct CopyImageToImageInfo
  {
    using NativeType = VkCopyImageToImageInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyImageToImageInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyImageToImageInfo( HostImageCopyFlags flags_          = {},
                                               Image              srcImage_       = {},
                                               ImageLayout        srcImageLayout_ = ImageLayout::eUndefined,
                                               Image              dstImage_       = {},
                                               ImageLayout        dstImageLayout_ = ImageLayout::eUndefined,
                                               uint32_t           regionCount_    = {},
                                               ImageCopy2 const * pRegions_       = {},
                                               void const *       pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , srcImage{ srcImage_ }
      , srcImageLayout{ srcImageLayout_ }
      , dstImage{ dstImage_ }
      , dstImageLayout{ dstImageLayout_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyImageToImageInfo( CopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyImageToImageInfo( VkCopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyImageToImageInfo( *reinterpret_cast<CopyImageToImageInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyImageToImageInfo( HostImageCopyFlags                                flags_,
                          Image                                             srcImage_,
                          ImageLayout                                       srcImageLayout_,
                          Image                                             dstImage_,
                          ImageLayout                                       dstImageLayout_,
                          ArrayProxyNoTemporaries<ImageCopy2 const> const & regions_,
                          void const *                                      pNext_ = nullptr )
      : pNext( pNext_ )
      , flags( flags_ )
      , srcImage( srcImage_ )
      , srcImageLayout( srcImageLayout_ )
      , dstImage( dstImage_ )
      , dstImageLayout( dstImageLayout_ )
      , regionCount( static_cast<uint32_t>( regions_.size() ) )
      , pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyImageToImageInfo & operator=( CopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyImageToImageInfo & operator=( VkCopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyImageToImageInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setFlags( HostImageCopyFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setFlags( HostImageCopyFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setPRegions( ImageCopy2 const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setPRegions( ImageCopy2 const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyImageToImageInfo & setRegions( ArrayProxyNoTemporaries<ImageCopy2 const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyImageToImageInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyImageToImageInfo const *>( this );
    }

    operator VkCopyImageToImageInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyImageToImageInfo *>( this );
    }

    operator VkCopyImageToImageInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyImageToImageInfo const *>( this );
    }

    operator VkCopyImageToImageInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyImageToImageInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               HostImageCopyFlags const &,
               Image const &,
               ImageLayout const &,
               Image const &,
               ImageLayout const &,
               uint32_t const &,
               ImageCopy2 const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyImageToImageInfo const & ) const = default;
#else
    bool operator==( CopyImageToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcImage == rhs.srcImage ) &&
             ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) &&
             ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyImageToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType      sType          = StructureType::eCopyImageToImageInfo;
    void const *       pNext          = {};
    HostImageCopyFlags flags          = {};
    Image              srcImage       = {};
    ImageLayout        srcImageLayout = ImageLayout::eUndefined;
    Image              dstImage       = {};
    ImageLayout        dstImageLayout = ImageLayout::eUndefined;
    uint32_t           regionCount    = {};
    ImageCopy2 const * pRegions       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyImageToImageInfo>
  {
    using Type = CopyImageToImageInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyImageToImageInfo>
  {
    using Type = CopyImageToImageInfo;
  };

  using CopyImageToImageInfoEXT = CopyImageToImageInfo;

  // wrapper struct for struct VkImageToMemoryCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageToMemoryCopy.html
  struct ImageToMemoryCopy
  {
    using NativeType = VkImageToMemoryCopy;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eImageToMemoryCopy;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ImageToMemoryCopy( void *                 pHostPointer_      = {},
                                            uint32_t               memoryRowLength_   = {},
                                            uint32_t               memoryImageHeight_ = {},
                                            ImageSubresourceLayers imageSubresource_  = {},
                                            Offset3D               imageOffset_       = {},
                                            Extent3D               imageExtent_       = {},
                                            void const *           pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pHostPointer{ pHostPointer_ }
      , memoryRowLength{ memoryRowLength_ }
      , memoryImageHeight{ memoryImageHeight_ }
      , imageSubresource{ imageSubresource_ }
      , imageOffset{ imageOffset_ }
      , imageExtent{ imageExtent_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ImageToMemoryCopy( ImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ImageToMemoryCopy( VkImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT : ImageToMemoryCopy( *reinterpret_cast<ImageToMemoryCopy const *>( &rhs ) ) {}

    ImageToMemoryCopy & operator=( ImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ImageToMemoryCopy & operator=( VkImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ImageToMemoryCopy const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setPHostPointer( void * pHostPointer_ ) & VULKAN_HPP_NOEXCEPT
    {
      pHostPointer = pHostPointer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setPHostPointer( void * pHostPointer_ ) && VULKAN_HPP_NOEXCEPT
    {
      pHostPointer = pHostPointer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setMemoryRowLength( uint32_t memoryRowLength_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryRowLength = memoryRowLength_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setMemoryRowLength( uint32_t memoryRowLength_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryRowLength = memoryRowLength_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setMemoryImageHeight( uint32_t memoryImageHeight_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryImageHeight = memoryImageHeight_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setMemoryImageHeight( uint32_t memoryImageHeight_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryImageHeight = memoryImageHeight_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkImageToMemoryCopy const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageToMemoryCopy const *>( this );
    }

    operator VkImageToMemoryCopy &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageToMemoryCopy *>( this );
    }

    operator VkImageToMemoryCopy const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageToMemoryCopy const *>( this );
    }

    operator VkImageToMemoryCopy *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageToMemoryCopy *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               void * const &,
               uint32_t const &,
               uint32_t const &,
               ImageSubresourceLayers const &,
               Offset3D const &,
               Extent3D const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pHostPointer, memoryRowLength, memoryImageHeight, imageSubresource, imageOffset, imageExtent );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ImageToMemoryCopy const & ) const = default;
#else
    bool operator==( ImageToMemoryCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pHostPointer == rhs.pHostPointer ) && ( memoryRowLength == rhs.memoryRowLength ) &&
             ( memoryImageHeight == rhs.memoryImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) &&
             ( imageExtent == rhs.imageExtent );
#  endif
    }

    bool operator!=( ImageToMemoryCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType             = StructureType::eImageToMemoryCopy;
    void const *           pNext             = {};
    void *                 pHostPointer      = {};
    uint32_t               memoryRowLength   = {};
    uint32_t               memoryImageHeight = {};
    ImageSubresourceLayers imageSubresource  = {};
    Offset3D               imageOffset       = {};
    Extent3D               imageExtent       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkImageToMemoryCopy>
  {
    using Type = ImageToMemoryCopy;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eImageToMemoryCopy>
  {
    using Type = ImageToMemoryCopy;
  };

  using ImageToMemoryCopyEXT = ImageToMemoryCopy;

  // wrapper struct for struct VkCopyImageToMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageToMemoryInfo.html
  struct CopyImageToMemoryInfo
  {
    using NativeType = VkCopyImageToMemoryInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyImageToMemoryInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyImageToMemoryInfo( HostImageCopyFlags        flags_          = {},
                                                Image                     srcImage_       = {},
                                                ImageLayout               srcImageLayout_ = ImageLayout::eUndefined,
                                                uint32_t                  regionCount_    = {},
                                                ImageToMemoryCopy const * pRegions_       = {},
                                                void const *              pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , srcImage{ srcImage_ }
      , srcImageLayout{ srcImageLayout_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyImageToMemoryInfo( CopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyImageToMemoryInfo( VkCopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyImageToMemoryInfo( *reinterpret_cast<CopyImageToMemoryInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyImageToMemoryInfo( HostImageCopyFlags                                       flags_,
                           Image                                                    srcImage_,
                           ImageLayout                                              srcImageLayout_,
                           ArrayProxyNoTemporaries<ImageToMemoryCopy const> const & regions_,
                           void const *                                             pNext_ = nullptr )
      : pNext( pNext_ )
      , flags( flags_ )
      , srcImage( srcImage_ )
      , srcImageLayout( srcImageLayout_ )
      , regionCount( static_cast<uint32_t>( regions_.size() ) )
      , pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyImageToMemoryInfo & operator=( CopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyImageToMemoryInfo & operator=( VkCopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyImageToMemoryInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setFlags( HostImageCopyFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setFlags( HostImageCopyFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImage = srcImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcImageLayout = srcImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setPRegions( ImageToMemoryCopy const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setPRegions( ImageToMemoryCopy const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyImageToMemoryInfo & setRegions( ArrayProxyNoTemporaries<ImageToMemoryCopy const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyImageToMemoryInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyImageToMemoryInfo const *>( this );
    }

    operator VkCopyImageToMemoryInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyImageToMemoryInfo *>( this );
    }

    operator VkCopyImageToMemoryInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyImageToMemoryInfo const *>( this );
    }

    operator VkCopyImageToMemoryInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyImageToMemoryInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               HostImageCopyFlags const &,
               Image const &,
               ImageLayout const &,
               uint32_t const &,
               ImageToMemoryCopy const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, srcImage, srcImageLayout, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyImageToMemoryInfo const & ) const = default;
#else
    bool operator==( CopyImageToMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcImage == rhs.srcImage ) &&
             ( srcImageLayout == rhs.srcImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyImageToMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType             sType          = StructureType::eCopyImageToMemoryInfo;
    void const *              pNext          = {};
    HostImageCopyFlags        flags          = {};
    Image                     srcImage       = {};
    ImageLayout               srcImageLayout = ImageLayout::eUndefined;
    uint32_t                  regionCount    = {};
    ImageToMemoryCopy const * pRegions       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyImageToMemoryInfo>
  {
    using Type = CopyImageToMemoryInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyImageToMemoryInfo>
  {
    using Type = CopyImageToMemoryInfo;
  };

  using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo;

  // wrapper struct for struct VkCopyMemoryIndirectCommandKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectCommandKHR.html
  struct CopyMemoryIndirectCommandKHR
  {
    using NativeType = VkCopyMemoryIndirectCommandKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      CopyMemoryIndirectCommandKHR( DeviceAddress srcAddress_ = {}, DeviceAddress dstAddress_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
      : srcAddress{ srcAddress_ }
      , dstAddress{ dstAddress_ }
      , size{ size_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyMemoryIndirectCommandKHR( CopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyMemoryIndirectCommandKHR( VkCopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyMemoryIndirectCommandKHR( *reinterpret_cast<CopyMemoryIndirectCommandKHR const *>( &rhs ) )
    {
    }

    CopyMemoryIndirectCommandKHR & operator=( CopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyMemoryIndirectCommandKHR & operator=( VkCopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyMemoryIndirectCommandKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcAddress = srcAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcAddress = srcAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setDstAddress( DeviceAddress dstAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstAddress = dstAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR && setDstAddress( DeviceAddress dstAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstAddress = dstAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyMemoryIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryIndirectCommandKHR const *>( this );
    }

    operator VkCopyMemoryIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryIndirectCommandKHR *>( this );
    }

    operator VkCopyMemoryIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryIndirectCommandKHR const *>( this );
    }

    operator VkCopyMemoryIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryIndirectCommandKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, DeviceAddress const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( srcAddress, dstAddress, size );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyMemoryIndirectCommandKHR const & ) const = default;
#else
    bool operator==( CopyMemoryIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( srcAddress == rhs.srcAddress ) && ( dstAddress == rhs.dstAddress ) && ( size == rhs.size );
#  endif
    }

    bool operator!=( CopyMemoryIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress srcAddress = {};
    DeviceAddress dstAddress = {};
    DeviceSize    size       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyMemoryIndirectCommandKHR>
  {
    using Type = CopyMemoryIndirectCommandKHR;
  };
#endif
  using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR;

  // wrapper struct for struct VkCopyMemoryIndirectInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectInfoKHR.html
  struct CopyMemoryIndirectInfoKHR
  {
    using NativeType = VkCopyMemoryIndirectInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyMemoryIndirectInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyMemoryIndirectInfoKHR( AddressCopyFlagsKHR          srcCopyFlags_     = {},
                                                    AddressCopyFlagsKHR          dstCopyFlags_     = {},
                                                    uint32_t                     copyCount_        = {},
                                                    StridedDeviceAddressRangeKHR copyAddressRange_ = {},
                                                    void const *                 pNext_            = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcCopyFlags{ srcCopyFlags_ }
      , dstCopyFlags{ dstCopyFlags_ }
      , copyCount{ copyCount_ }
      , copyAddressRange{ copyAddressRange_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyMemoryIndirectInfoKHR( CopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyMemoryIndirectInfoKHR( VkCopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyMemoryIndirectInfoKHR( *reinterpret_cast<CopyMemoryIndirectInfoKHR const *>( &rhs ) )
    {
    }

    CopyMemoryIndirectInfoKHR & operator=( CopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyMemoryIndirectInfoKHR & operator=( VkCopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyMemoryIndirectInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcCopyFlags = srcCopyFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcCopyFlags = srcCopyFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setDstCopyFlags( AddressCopyFlagsKHR dstCopyFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstCopyFlags = dstCopyFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setDstCopyFlags( AddressCopyFlagsKHR dstCopyFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstCopyFlags = dstCopyFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setCopyCount( uint32_t copyCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      copyCount = copyCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setCopyCount( uint32_t copyCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      copyCount = copyCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      copyAddressRange = copyAddressRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      copyAddressRange = copyAddressRange_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyMemoryIndirectInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryIndirectInfoKHR const *>( this );
    }

    operator VkCopyMemoryIndirectInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryIndirectInfoKHR *>( this );
    }

    operator VkCopyMemoryIndirectInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryIndirectInfoKHR const *>( this );
    }

    operator VkCopyMemoryIndirectInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryIndirectInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AddressCopyFlagsKHR const &,
               AddressCopyFlagsKHR const &,
               uint32_t const &,
               StridedDeviceAddressRangeKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcCopyFlags, dstCopyFlags, copyCount, copyAddressRange );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyMemoryIndirectInfoKHR const & ) const = default;
#else
    bool operator==( CopyMemoryIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcCopyFlags == rhs.srcCopyFlags ) && ( dstCopyFlags == rhs.dstCopyFlags ) &&
             ( copyCount == rhs.copyCount ) && ( copyAddressRange == rhs.copyAddressRange );
#  endif
    }

    bool operator!=( CopyMemoryIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                sType            = StructureType::eCopyMemoryIndirectInfoKHR;
    void const *                 pNext            = {};
    AddressCopyFlagsKHR          srcCopyFlags     = {};
    AddressCopyFlagsKHR          dstCopyFlags     = {};
    uint32_t                     copyCount        = {};
    StridedDeviceAddressRangeKHR copyAddressRange = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyMemoryIndirectInfoKHR>
  {
    using Type = CopyMemoryIndirectInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyMemoryIndirectInfoKHR>
  {
    using Type = CopyMemoryIndirectInfoKHR;
  };

  // wrapper struct for struct VkCopyMemoryToAccelerationStructureInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html
  struct CopyMemoryToAccelerationStructureInfoKHR
  {
    using NativeType = VkCopyMemoryToAccelerationStructureInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyMemoryToAccelerationStructureInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR( DeviceOrHostAddressConstKHR      src_   = {},
                                                                      AccelerationStructureKHR         dst_   = {},
                                                                      CopyAccelerationStructureModeKHR mode_  = CopyAccelerationStructureModeKHR::eClone,
                                                                      void const *                     pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , src{ src_ }
      , dst{ dst_ }
      , mode{ mode_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyMemoryToAccelerationStructureInfoKHR( VkCopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyMemoryToAccelerationStructureInfoKHR( *reinterpret_cast<CopyMemoryToAccelerationStructureInfoKHR const *>( &rhs ) )
    {
    }

    CopyMemoryToAccelerationStructureInfoKHR & operator=( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyMemoryToAccelerationStructureInfoKHR & operator=( VkCopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyMemoryToAccelerationStructureInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setSrc( DeviceOrHostAddressConstKHR const & src_ ) & VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setSrc( DeviceOrHostAddressConstKHR const & src_ ) && VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setDst( AccelerationStructureKHR dst_ ) & VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setDst( AccelerationStructureKHR dst_ ) && VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setMode( CopyAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setMode( CopyAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR const *>( this );
    }

    operator VkCopyMemoryToAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR *>( this );
    }

    operator VkCopyMemoryToAccelerationStructureInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR const *>( this );
    }

    operator VkCopyMemoryToAccelerationStructureInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DeviceOrHostAddressConstKHR const &,
               AccelerationStructureKHR const &,
               CopyAccelerationStructureModeKHR const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, src, dst, mode );
    }
#endif

  public:
    StructureType                    sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR;
    void const *                     pNext = {};
    DeviceOrHostAddressConstKHR      src   = {};
    AccelerationStructureKHR         dst   = {};
    CopyAccelerationStructureModeKHR mode  = CopyAccelerationStructureModeKHR::eClone;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyMemoryToAccelerationStructureInfoKHR>
  {
    using Type = CopyMemoryToAccelerationStructureInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyMemoryToAccelerationStructureInfoKHR>
  {
    using Type = CopyMemoryToAccelerationStructureInfoKHR;
  };

  // wrapper struct for struct VkCopyMemoryToImageIndirectCommandKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectCommandKHR.html
  struct CopyMemoryToImageIndirectCommandKHR
  {
    using NativeType = VkCopyMemoryToImageIndirectCommandKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandKHR( DeviceAddress          srcAddress_        = {},
                                                              uint32_t               bufferRowLength_   = {},
                                                              uint32_t               bufferImageHeight_ = {},
                                                              ImageSubresourceLayers imageSubresource_  = {},
                                                              Offset3D               imageOffset_       = {},
                                                              Extent3D               imageExtent_       = {} ) VULKAN_HPP_NOEXCEPT
      : srcAddress{ srcAddress_ }
      , bufferRowLength{ bufferRowLength_ }
      , bufferImageHeight{ bufferImageHeight_ }
      , imageSubresource{ imageSubresource_ }
      , imageOffset{ imageOffset_ }
      , imageExtent{ imageExtent_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandKHR( CopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyMemoryToImageIndirectCommandKHR( VkCopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyMemoryToImageIndirectCommandKHR( *reinterpret_cast<CopyMemoryToImageIndirectCommandKHR const *>( &rhs ) )
    {
    }

    CopyMemoryToImageIndirectCommandKHR & operator=( CopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyMemoryToImageIndirectCommandKHR & operator=( VkCopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyMemoryToImageIndirectCommandKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcAddress = srcAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcAddress = srcAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setBufferRowLength( uint32_t bufferRowLength_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferRowLength = bufferRowLength_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setBufferRowLength( uint32_t bufferRowLength_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferRowLength = bufferRowLength_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setBufferImageHeight( uint32_t bufferImageHeight_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferImageHeight = bufferImageHeight_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setBufferImageHeight( uint32_t bufferImageHeight_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferImageHeight = bufferImageHeight_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyMemoryToImageIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToImageIndirectCommandKHR const *>( this );
    }

    operator VkCopyMemoryToImageIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToImageIndirectCommandKHR *>( this );
    }

    operator VkCopyMemoryToImageIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToImageIndirectCommandKHR const *>( this );
    }

    operator VkCopyMemoryToImageIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToImageIndirectCommandKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, uint32_t const &, uint32_t const &, ImageSubresourceLayers const &, Offset3D const &, Extent3D const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( srcAddress, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyMemoryToImageIndirectCommandKHR const & ) const = default;
#else
    bool operator==( CopyMemoryToImageIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( srcAddress == rhs.srcAddress ) && ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) &&
             ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent );
#  endif
    }

    bool operator!=( CopyMemoryToImageIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress          srcAddress        = {};
    uint32_t               bufferRowLength   = {};
    uint32_t               bufferImageHeight = {};
    ImageSubresourceLayers imageSubresource  = {};
    Offset3D               imageOffset       = {};
    Extent3D               imageExtent       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyMemoryToImageIndirectCommandKHR>
  {
    using Type = CopyMemoryToImageIndirectCommandKHR;
  };
#endif
  using CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR;

  // wrapper struct for struct VkCopyMemoryToImageIndirectInfoKHR, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectInfoKHR.html
  struct CopyMemoryToImageIndirectInfoKHR
  {
    using NativeType = VkCopyMemoryToImageIndirectInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyMemoryToImageIndirectInfoKHR;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectInfoKHR( AddressCopyFlagsKHR            srcCopyFlags_       = {},
                                                           uint32_t                       copyCount_          = {},
                                                           StridedDeviceAddressRangeKHR   copyAddressRange_   = {},
                                                           Image                          dstImage_           = {},
                                                           ImageLayout                    dstImageLayout_     = ImageLayout::eUndefined,
                                                           ImageSubresourceLayers const * pImageSubresources_ = {},
                                                           void const *                   pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcCopyFlags{ srcCopyFlags_ }
      , copyCount{ copyCount_ }
      , copyAddressRange{ copyAddressRange_ }
      , dstImage{ dstImage_ }
      , dstImageLayout{ dstImageLayout_ }
      , pImageSubresources{ pImageSubresources_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectInfoKHR( CopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyMemoryToImageIndirectInfoKHR( VkCopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyMemoryToImageIndirectInfoKHR( *reinterpret_cast<CopyMemoryToImageIndirectInfoKHR const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyMemoryToImageIndirectInfoKHR( AddressCopyFlagsKHR                                           srcCopyFlags_,
                                      StridedDeviceAddressRangeKHR                                  copyAddressRange_,
                                      Image                                                         dstImage_,
                                      ImageLayout                                                   dstImageLayout_,
                                      ArrayProxyNoTemporaries<ImageSubresourceLayers const> const & imageSubresources_,
                                      void const *                                                  pNext_ = nullptr )
      : pNext( pNext_ )
      , srcCopyFlags( srcCopyFlags_ )
      , copyCount( static_cast<uint32_t>( imageSubresources_.size() ) )
      , copyAddressRange( copyAddressRange_ )
      , dstImage( dstImage_ )
      , dstImageLayout( dstImageLayout_ )
      , pImageSubresources( imageSubresources_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyMemoryToImageIndirectInfoKHR & operator=( CopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyMemoryToImageIndirectInfoKHR & operator=( VkCopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyMemoryToImageIndirectInfoKHR const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcCopyFlags = srcCopyFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcCopyFlags = srcCopyFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setCopyCount( uint32_t copyCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      copyCount = copyCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setCopyCount( uint32_t copyCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      copyCount = copyCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      copyAddressRange = copyAddressRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      copyAddressRange = copyAddressRange_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setPImageSubresources( ImageSubresourceLayers const * pImageSubresources_ ) & VULKAN_HPP_NOEXCEPT
    {
      pImageSubresources = pImageSubresources_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setPImageSubresources( ImageSubresourceLayers const * pImageSubresources_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pImageSubresources = pImageSubresources_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyMemoryToImageIndirectInfoKHR &
      setImageSubresources( ArrayProxyNoTemporaries<ImageSubresourceLayers const> const & imageSubresources_ ) VULKAN_HPP_NOEXCEPT
    {
      copyCount          = static_cast<uint32_t>( imageSubresources_.size() );
      pImageSubresources = imageSubresources_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyMemoryToImageIndirectInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToImageIndirectInfoKHR const *>( this );
    }

    operator VkCopyMemoryToImageIndirectInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToImageIndirectInfoKHR *>( this );
    }

    operator VkCopyMemoryToImageIndirectInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToImageIndirectInfoKHR const *>( this );
    }

    operator VkCopyMemoryToImageIndirectInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToImageIndirectInfoKHR *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               AddressCopyFlagsKHR const &,
               uint32_t const &,
               StridedDeviceAddressRangeKHR const &,
               Image const &,
               ImageLayout const &,
               ImageSubresourceLayers const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcCopyFlags, copyCount, copyAddressRange, dstImage, dstImageLayout, pImageSubresources );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyMemoryToImageIndirectInfoKHR const & ) const = default;
#else
    bool operator==( CopyMemoryToImageIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcCopyFlags == rhs.srcCopyFlags ) && ( copyCount == rhs.copyCount ) &&
             ( copyAddressRange == rhs.copyAddressRange ) && ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) &&
             ( pImageSubresources == rhs.pImageSubresources );
#  endif
    }

    bool operator!=( CopyMemoryToImageIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                  sType              = StructureType::eCopyMemoryToImageIndirectInfoKHR;
    void const *                   pNext              = {};
    AddressCopyFlagsKHR            srcCopyFlags       = {};
    uint32_t                       copyCount          = {};
    StridedDeviceAddressRangeKHR   copyAddressRange   = {};
    Image                          dstImage           = {};
    ImageLayout                    dstImageLayout     = ImageLayout::eUndefined;
    ImageSubresourceLayers const * pImageSubresources = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyMemoryToImageIndirectInfoKHR>
  {
    using Type = CopyMemoryToImageIndirectInfoKHR;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyMemoryToImageIndirectInfoKHR>
  {
    using Type = CopyMemoryToImageIndirectInfoKHR;
  };

  // wrapper struct for struct VkMemoryToImageCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryToImageCopy.html
  struct MemoryToImageCopy
  {
    using NativeType = VkMemoryToImageCopy;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eMemoryToImageCopy;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR MemoryToImageCopy( void const *           pHostPointer_      = {},
                                            uint32_t               memoryRowLength_   = {},
                                            uint32_t               memoryImageHeight_ = {},
                                            ImageSubresourceLayers imageSubresource_  = {},
                                            Offset3D               imageOffset_       = {},
                                            Extent3D               imageExtent_       = {},
                                            void const *           pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pHostPointer{ pHostPointer_ }
      , memoryRowLength{ memoryRowLength_ }
      , memoryImageHeight{ memoryImageHeight_ }
      , imageSubresource{ imageSubresource_ }
      , imageOffset{ imageOffset_ }
      , imageExtent{ imageExtent_ }
    {
    }

    VULKAN_HPP_CONSTEXPR MemoryToImageCopy( MemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    MemoryToImageCopy( VkMemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryToImageCopy( *reinterpret_cast<MemoryToImageCopy const *>( &rhs ) ) {}

    MemoryToImageCopy & operator=( MemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    MemoryToImageCopy & operator=( VkMemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<MemoryToImageCopy const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setPHostPointer( void const * pHostPointer_ ) & VULKAN_HPP_NOEXCEPT
    {
      pHostPointer = pHostPointer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setPHostPointer( void const * pHostPointer_ ) && VULKAN_HPP_NOEXCEPT
    {
      pHostPointer = pHostPointer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setMemoryRowLength( uint32_t memoryRowLength_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryRowLength = memoryRowLength_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setMemoryRowLength( uint32_t memoryRowLength_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryRowLength = memoryRowLength_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setMemoryImageHeight( uint32_t memoryImageHeight_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryImageHeight = memoryImageHeight_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setMemoryImageHeight( uint32_t memoryImageHeight_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryImageHeight = memoryImageHeight_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageSubresource = imageSubresource_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageOffset = imageOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageExtent = imageExtent_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkMemoryToImageCopy const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkMemoryToImageCopy const *>( this );
    }

    operator VkMemoryToImageCopy &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkMemoryToImageCopy *>( this );
    }

    operator VkMemoryToImageCopy const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkMemoryToImageCopy const *>( this );
    }

    operator VkMemoryToImageCopy *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkMemoryToImageCopy *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               void const * const &,
               uint32_t const &,
               uint32_t const &,
               ImageSubresourceLayers const &,
               Offset3D const &,
               Extent3D const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pHostPointer, memoryRowLength, memoryImageHeight, imageSubresource, imageOffset, imageExtent );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( MemoryToImageCopy const & ) const = default;
#else
    bool operator==( MemoryToImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pHostPointer == rhs.pHostPointer ) && ( memoryRowLength == rhs.memoryRowLength ) &&
             ( memoryImageHeight == rhs.memoryImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) &&
             ( imageExtent == rhs.imageExtent );
#  endif
    }

    bool operator!=( MemoryToImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType             = StructureType::eMemoryToImageCopy;
    void const *           pNext             = {};
    void const *           pHostPointer      = {};
    uint32_t               memoryRowLength   = {};
    uint32_t               memoryImageHeight = {};
    ImageSubresourceLayers imageSubresource  = {};
    Offset3D               imageOffset       = {};
    Extent3D               imageExtent       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkMemoryToImageCopy>
  {
    using Type = MemoryToImageCopy;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eMemoryToImageCopy>
  {
    using Type = MemoryToImageCopy;
  };

  using MemoryToImageCopyEXT = MemoryToImageCopy;

  // wrapper struct for struct VkCopyMemoryToImageInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageInfo.html
  struct CopyMemoryToImageInfo
  {
    using NativeType = VkCopyMemoryToImageInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyMemoryToImageInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyMemoryToImageInfo( HostImageCopyFlags        flags_          = {},
                                                Image                     dstImage_       = {},
                                                ImageLayout               dstImageLayout_ = ImageLayout::eUndefined,
                                                uint32_t                  regionCount_    = {},
                                                MemoryToImageCopy const * pRegions_       = {},
                                                void const *              pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , dstImage{ dstImage_ }
      , dstImageLayout{ dstImageLayout_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyMemoryToImageInfo( CopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyMemoryToImageInfo( VkCopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyMemoryToImageInfo( *reinterpret_cast<CopyMemoryToImageInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyMemoryToImageInfo( HostImageCopyFlags                                       flags_,
                           Image                                                    dstImage_,
                           ImageLayout                                              dstImageLayout_,
                           ArrayProxyNoTemporaries<MemoryToImageCopy const> const & regions_,
                           void const *                                             pNext_ = nullptr )
      : pNext( pNext_ )
      , flags( flags_ )
      , dstImage( dstImage_ )
      , dstImageLayout( dstImageLayout_ )
      , regionCount( static_cast<uint32_t>( regions_.size() ) )
      , pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyMemoryToImageInfo & operator=( CopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyMemoryToImageInfo & operator=( VkCopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyMemoryToImageInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setFlags( HostImageCopyFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setFlags( HostImageCopyFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImage = dstImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstImageLayout = dstImageLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setPRegions( MemoryToImageCopy const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setPRegions( MemoryToImageCopy const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyMemoryToImageInfo & setRegions( ArrayProxyNoTemporaries<MemoryToImageCopy const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyMemoryToImageInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToImageInfo const *>( this );
    }

    operator VkCopyMemoryToImageInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToImageInfo *>( this );
    }

    operator VkCopyMemoryToImageInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToImageInfo const *>( this );
    }

    operator VkCopyMemoryToImageInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToImageInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               HostImageCopyFlags const &,
               Image const &,
               ImageLayout const &,
               uint32_t const &,
               MemoryToImageCopy const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, dstImage, dstImageLayout, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyMemoryToImageInfo const & ) const = default;
#else
    bool operator==( CopyMemoryToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dstImage == rhs.dstImage ) &&
             ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyMemoryToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType             sType          = StructureType::eCopyMemoryToImageInfo;
    void const *              pNext          = {};
    HostImageCopyFlags        flags          = {};
    Image                     dstImage       = {};
    ImageLayout               dstImageLayout = ImageLayout::eUndefined;
    uint32_t                  regionCount    = {};
    MemoryToImageCopy const * pRegions       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyMemoryToImageInfo>
  {
    using Type = CopyMemoryToImageInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyMemoryToImageInfo>
  {
    using Type = CopyMemoryToImageInfo;
  };

  using CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo;

  // wrapper struct for struct VkCopyMemoryToMicromapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToMicromapInfoEXT.html
  struct CopyMemoryToMicromapInfoEXT
  {
    using NativeType = VkCopyMemoryToMicromapInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyMemoryToMicromapInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT( DeviceOrHostAddressConstKHR src_   = {},
                                                         MicromapEXT                 dst_   = {},
                                                         CopyMicromapModeEXT         mode_  = CopyMicromapModeEXT::eClone,
                                                         void const *                pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , src{ src_ }
      , dst{ dst_ }
      , mode{ mode_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT( CopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyMemoryToMicromapInfoEXT( VkCopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyMemoryToMicromapInfoEXT( *reinterpret_cast<CopyMemoryToMicromapInfoEXT const *>( &rhs ) )
    {
    }

    CopyMemoryToMicromapInfoEXT & operator=( CopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyMemoryToMicromapInfoEXT & operator=( VkCopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyMemoryToMicromapInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setSrc( DeviceOrHostAddressConstKHR const & src_ ) & VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setSrc( DeviceOrHostAddressConstKHR const & src_ ) && VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setDst( MicromapEXT dst_ ) & VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setDst( MicromapEXT dst_ ) && VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setMode( CopyMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setMode( CopyMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyMemoryToMicromapInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToMicromapInfoEXT const *>( this );
    }

    operator VkCopyMemoryToMicromapInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMemoryToMicromapInfoEXT *>( this );
    }

    operator VkCopyMemoryToMicromapInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToMicromapInfoEXT const *>( this );
    }

    operator VkCopyMemoryToMicromapInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMemoryToMicromapInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceOrHostAddressConstKHR const &, MicromapEXT const &, CopyMicromapModeEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, src, dst, mode );
    }
#endif

  public:
    StructureType               sType = StructureType::eCopyMemoryToMicromapInfoEXT;
    void const *                pNext = {};
    DeviceOrHostAddressConstKHR src   = {};
    MicromapEXT                 dst   = {};
    CopyMicromapModeEXT         mode  = CopyMicromapModeEXT::eClone;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyMemoryToMicromapInfoEXT>
  {
    using Type = CopyMemoryToMicromapInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyMemoryToMicromapInfoEXT>
  {
    using Type = CopyMemoryToMicromapInfoEXT;
  };

  // wrapper struct for struct VkCopyMicromapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMicromapInfoEXT.html
  struct CopyMicromapInfoEXT
  {
    using NativeType = VkCopyMicromapInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyMicromapInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyMicromapInfoEXT( MicromapEXT         src_   = {},
                                              MicromapEXT         dst_   = {},
                                              CopyMicromapModeEXT mode_  = CopyMicromapModeEXT::eClone,
                                              void const *        pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , src{ src_ }
      , dst{ dst_ }
      , mode{ mode_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyMicromapInfoEXT( CopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyMicromapInfoEXT( VkCopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : CopyMicromapInfoEXT( *reinterpret_cast<CopyMicromapInfoEXT const *>( &rhs ) )
    {
    }

    CopyMicromapInfoEXT & operator=( CopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyMicromapInfoEXT & operator=( VkCopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyMicromapInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setSrc( MicromapEXT src_ ) & VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setSrc( MicromapEXT src_ ) && VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setDst( MicromapEXT dst_ ) & VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setDst( MicromapEXT dst_ ) && VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setMode( CopyMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setMode( CopyMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyMicromapInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMicromapInfoEXT const *>( this );
    }

    operator VkCopyMicromapInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMicromapInfoEXT *>( this );
    }

    operator VkCopyMicromapInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMicromapInfoEXT const *>( this );
    }

    operator VkCopyMicromapInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMicromapInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, MicromapEXT const &, MicromapEXT const &, CopyMicromapModeEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, src, dst, mode );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyMicromapInfoEXT const & ) const = default;
#else
    bool operator==( CopyMicromapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && ( mode == rhs.mode );
#  endif
    }

    bool operator!=( CopyMicromapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType       sType = StructureType::eCopyMicromapInfoEXT;
    void const *        pNext = {};
    MicromapEXT         src   = {};
    MicromapEXT         dst   = {};
    CopyMicromapModeEXT mode  = CopyMicromapModeEXT::eClone;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyMicromapInfoEXT>
  {
    using Type = CopyMicromapInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyMicromapInfoEXT>
  {
    using Type = CopyMicromapInfoEXT;
  };

  // wrapper struct for struct VkCopyMicromapToMemoryInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMicromapToMemoryInfoEXT.html
  struct CopyMicromapToMemoryInfoEXT
  {
    using NativeType = VkCopyMicromapToMemoryInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyMicromapToMemoryInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT( MicromapEXT            src_   = {},
                                                         DeviceOrHostAddressKHR dst_   = {},
                                                         CopyMicromapModeEXT    mode_  = CopyMicromapModeEXT::eClone,
                                                         void const *           pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , src{ src_ }
      , dst{ dst_ }
      , mode{ mode_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT( CopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyMicromapToMemoryInfoEXT( VkCopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : CopyMicromapToMemoryInfoEXT( *reinterpret_cast<CopyMicromapToMemoryInfoEXT const *>( &rhs ) )
    {
    }

    CopyMicromapToMemoryInfoEXT & operator=( CopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyMicromapToMemoryInfoEXT & operator=( VkCopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyMicromapToMemoryInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setSrc( MicromapEXT src_ ) & VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setSrc( MicromapEXT src_ ) && VULKAN_HPP_NOEXCEPT
    {
      src = src_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setDst( DeviceOrHostAddressKHR const & dst_ ) & VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setDst( DeviceOrHostAddressKHR const & dst_ ) && VULKAN_HPP_NOEXCEPT
    {
      dst = dst_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setMode( CopyMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setMode( CopyMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyMicromapToMemoryInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMicromapToMemoryInfoEXT const *>( this );
    }

    operator VkCopyMicromapToMemoryInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyMicromapToMemoryInfoEXT *>( this );
    }

    operator VkCopyMicromapToMemoryInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMicromapToMemoryInfoEXT const *>( this );
    }

    operator VkCopyMicromapToMemoryInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyMicromapToMemoryInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, MicromapEXT const &, DeviceOrHostAddressKHR const &, CopyMicromapModeEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, src, dst, mode );
    }
#endif

  public:
    StructureType          sType = StructureType::eCopyMicromapToMemoryInfoEXT;
    void const *           pNext = {};
    MicromapEXT            src   = {};
    DeviceOrHostAddressKHR dst   = {};
    CopyMicromapModeEXT    mode  = CopyMicromapModeEXT::eClone;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyMicromapToMemoryInfoEXT>
  {
    using Type = CopyMicromapToMemoryInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyMicromapToMemoryInfoEXT>
  {
    using Type = CopyMicromapToMemoryInfoEXT;
  };

  // wrapper struct for struct VkTensorCopyARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCopyARM.html
  struct TensorCopyARM
  {
    using NativeType = VkTensorCopyARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eTensorCopyARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR TensorCopyARM( uint32_t         dimensionCount_ = {},
                                        uint64_t const * pSrcOffset_     = {},
                                        uint64_t const * pDstOffset_     = {},
                                        uint64_t const * pExtent_        = {},
                                        void const *     pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , dimensionCount{ dimensionCount_ }
      , pSrcOffset{ pSrcOffset_ }
      , pDstOffset{ pDstOffset_ }
      , pExtent{ pExtent_ }
    {
    }

    VULKAN_HPP_CONSTEXPR TensorCopyARM( TensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    TensorCopyARM( VkTensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT : TensorCopyARM( *reinterpret_cast<TensorCopyARM const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    TensorCopyARM( ArrayProxyNoTemporaries<uint64_t const> const & srcOffset_,
                   ArrayProxyNoTemporaries<uint64_t const> const & dstOffset_ = {},
                   ArrayProxyNoTemporaries<uint64_t const> const & extent_    = {},
                   void const *                                    pNext_     = nullptr )
      : pNext( pNext_ )
      , dimensionCount( static_cast<uint32_t>( srcOffset_.size() ) )
      , pSrcOffset( srcOffset_.data() )
      , pDstOffset( dstOffset_.data() )
      , pExtent( extent_.data() )
    {
#    ifdef VULKAN_HPP_NO_EXCEPTIONS
      VULKAN_HPP_ASSERT( srcOffset_.empty() || dstOffset_.empty() || ( srcOffset_.size() == dstOffset_.size() ) );
      VULKAN_HPP_ASSERT( srcOffset_.empty() || extent_.empty() || ( srcOffset_.size() == extent_.size() ) );
      VULKAN_HPP_ASSERT( dstOffset_.empty() || extent_.empty() || ( dstOffset_.size() == extent_.size() ) );
#    else
      if ( !srcOffset_.empty() && !dstOffset_.empty() && ( srcOffset_.size() != dstOffset_.size() ) )
      {
        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
                          "::TensorCopyARM::TensorCopyARM: !srcOffset_.empty() && !dstOffset_.empty() && ( srcOffset_.size() != dstOffset_.size() )" );
      }
      if ( !srcOffset_.empty() && !extent_.empty() && ( srcOffset_.size() != extent_.size() ) )
      {
        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
                          "::TensorCopyARM::TensorCopyARM: !srcOffset_.empty() && !extent_.empty() && ( srcOffset_.size() != extent_.size() )" );
      }
      if ( !dstOffset_.empty() && !extent_.empty() && ( dstOffset_.size() != extent_.size() ) )
      {
        throw LogicError( VULKAN_HPP_NAMESPACE_STRING
                          "::TensorCopyARM::TensorCopyARM: !dstOffset_.empty() && !extent_.empty() && ( dstOffset_.size() != extent_.size() )" );
      }
#    endif /*VULKAN_HPP_NO_EXCEPTIONS*/
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    TensorCopyARM & operator=( TensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    TensorCopyARM & operator=( VkTensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<TensorCopyARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setDimensionCount( uint32_t dimensionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      dimensionCount = dimensionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setDimensionCount( uint32_t dimensionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      dimensionCount = dimensionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPSrcOffset( uint64_t const * pSrcOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSrcOffset = pSrcOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPSrcOffset( uint64_t const * pSrcOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSrcOffset = pSrcOffset_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    TensorCopyARM & setSrcOffset( ArrayProxyNoTemporaries<uint64_t const> const & srcOffset_ ) VULKAN_HPP_NOEXCEPT
    {
      dimensionCount = static_cast<uint32_t>( srcOffset_.size() );
      pSrcOffset     = srcOffset_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPDstOffset( uint64_t const * pDstOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      pDstOffset = pDstOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPDstOffset( uint64_t const * pDstOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      pDstOffset = pDstOffset_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    TensorCopyARM & setDstOffset( ArrayProxyNoTemporaries<uint64_t const> const & dstOffset_ ) VULKAN_HPP_NOEXCEPT
    {
      dimensionCount = static_cast<uint32_t>( dstOffset_.size() );
      pDstOffset     = dstOffset_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPExtent( uint64_t const * pExtent_ ) & VULKAN_HPP_NOEXCEPT
    {
      pExtent = pExtent_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPExtent( uint64_t const * pExtent_ ) && VULKAN_HPP_NOEXCEPT
    {
      pExtent = pExtent_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    TensorCopyARM & setExtent( ArrayProxyNoTemporaries<uint64_t const> const & extent_ ) VULKAN_HPP_NOEXCEPT
    {
      dimensionCount = static_cast<uint32_t>( extent_.size() );
      pExtent        = extent_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkTensorCopyARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkTensorCopyARM const *>( this );
    }

    operator VkTensorCopyARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkTensorCopyARM *>( this );
    }

    operator VkTensorCopyARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkTensorCopyARM const *>( this );
    }

    operator VkTensorCopyARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkTensorCopyARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, uint64_t const * const &, uint64_t const * const &, uint64_t const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, dimensionCount, pSrcOffset, pDstOffset, pExtent );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( TensorCopyARM const & ) const = default;
#else
    bool operator==( TensorCopyARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dimensionCount == rhs.dimensionCount ) && ( pSrcOffset == rhs.pSrcOffset ) &&
             ( pDstOffset == rhs.pDstOffset ) && ( pExtent == rhs.pExtent );
#  endif
    }

    bool operator!=( TensorCopyARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType          = StructureType::eTensorCopyARM;
    void const *     pNext          = {};
    uint32_t         dimensionCount = {};
    uint64_t const * pSrcOffset     = {};
    uint64_t const * pDstOffset     = {};
    uint64_t const * pExtent        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkTensorCopyARM>
  {
    using Type = TensorCopyARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eTensorCopyARM>
  {
    using Type = TensorCopyARM;
  };

  // wrapper struct for struct VkCopyTensorInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyTensorInfoARM.html
  struct CopyTensorInfoARM
  {
    using NativeType = VkCopyTensorInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCopyTensorInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CopyTensorInfoARM( TensorARM             srcTensor_   = {},
                                            TensorARM             dstTensor_   = {},
                                            uint32_t              regionCount_ = {},
                                            TensorCopyARM const * pRegions_    = {},
                                            void const *          pNext_       = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcTensor{ srcTensor_ }
      , dstTensor{ dstTensor_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CopyTensorInfoARM( CopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CopyTensorInfoARM( VkCopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT : CopyTensorInfoARM( *reinterpret_cast<CopyTensorInfoARM const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyTensorInfoARM( TensorARM                                            srcTensor_,
                       TensorARM                                            dstTensor_,
                       ArrayProxyNoTemporaries<TensorCopyARM const> const & regions_,
                       void const *                                         pNext_ = nullptr )
      : pNext( pNext_ ), srcTensor( srcTensor_ ), dstTensor( dstTensor_ ), regionCount( static_cast<uint32_t>( regions_.size() ) ), pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CopyTensorInfoARM & operator=( CopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CopyTensorInfoARM & operator=( VkCopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CopyTensorInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setSrcTensor( TensorARM srcTensor_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcTensor = srcTensor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setSrcTensor( TensorARM srcTensor_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcTensor = srcTensor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setDstTensor( TensorARM dstTensor_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstTensor = dstTensor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setDstTensor( TensorARM dstTensor_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstTensor = dstTensor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setPRegions( TensorCopyARM const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setPRegions( TensorCopyARM const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CopyTensorInfoARM & setRegions( ArrayProxyNoTemporaries<TensorCopyARM const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCopyTensorInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyTensorInfoARM const *>( this );
    }

    operator VkCopyTensorInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCopyTensorInfoARM *>( this );
    }

    operator VkCopyTensorInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyTensorInfoARM const *>( this );
    }

    operator VkCopyTensorInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCopyTensorInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, TensorARM const &, TensorARM const &, uint32_t const &, TensorCopyARM const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcTensor, dstTensor, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CopyTensorInfoARM const & ) const = default;
#else
    bool operator==( CopyTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcTensor == rhs.srcTensor ) && ( dstTensor == rhs.dstTensor ) &&
             ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( CopyTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType         sType       = StructureType::eCopyTensorInfoARM;
    void const *          pNext       = {};
    TensorARM             srcTensor   = {};
    TensorARM             dstTensor   = {};
    uint32_t              regionCount = {};
    TensorCopyARM const * pRegions    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCopyTensorInfoARM>
  {
    using Type = CopyTensorInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCopyTensorInfoARM>
  {
    using Type = CopyTensorInfoARM;
  };

  // wrapper struct for struct VkCuFunctionCreateInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionCreateInfoNVX.html
  struct CuFunctionCreateInfoNVX
  {
    using NativeType = VkCuFunctionCreateInfoNVX;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCuFunctionCreateInfoNVX;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CuFunctionCreateInfoNVX( CuModuleNVX module_ = {}, char const * pName_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , module{ module_ }
      , pName{ pName_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CuFunctionCreateInfoNVX( CuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CuFunctionCreateInfoNVX( VkCuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
      : CuFunctionCreateInfoNVX( *reinterpret_cast<CuFunctionCreateInfoNVX const *>( &rhs ) )
    {
    }

    CuFunctionCreateInfoNVX & operator=( CuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CuFunctionCreateInfoNVX & operator=( VkCuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CuFunctionCreateInfoNVX const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX & setModule( CuModuleNVX module_ ) & VULKAN_HPP_NOEXCEPT
    {
      module = module_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX && setModule( CuModuleNVX module_ ) && VULKAN_HPP_NOEXCEPT
    {
      module = module_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX & setPName( char const * pName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pName = pName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX && setPName( char const * pName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pName = pName_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCuFunctionCreateInfoNVX const *>( this );
    }

    operator VkCuFunctionCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCuFunctionCreateInfoNVX *>( this );
    }

    operator VkCuFunctionCreateInfoNVX const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCuFunctionCreateInfoNVX const *>( this );
    }

    operator VkCuFunctionCreateInfoNVX *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCuFunctionCreateInfoNVX *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, CuModuleNVX const &, char const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, module, pName );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( auto cmp = module <=> rhs.module; cmp != 0 )
        return cmp;
      if ( pName != rhs.pName )
        if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) );
    }

    bool operator!=( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType sType  = StructureType::eCuFunctionCreateInfoNVX;
    void const *  pNext  = {};
    CuModuleNVX   module = {};
    char const *  pName  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCuFunctionCreateInfoNVX>
  {
    using Type = CuFunctionCreateInfoNVX;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCuFunctionCreateInfoNVX>
  {
    using Type = CuFunctionCreateInfoNVX;
  };

  // wrapper struct for struct VkCuLaunchInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuLaunchInfoNVX.html
  struct CuLaunchInfoNVX
  {
    using NativeType = VkCuLaunchInfoNVX;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCuLaunchInfoNVX;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CuLaunchInfoNVX( CuFunctionNVX        function_       = {},
                                          uint32_t             gridDimX_       = {},
                                          uint32_t             gridDimY_       = {},
                                          uint32_t             gridDimZ_       = {},
                                          uint32_t             blockDimX_      = {},
                                          uint32_t             blockDimY_      = {},
                                          uint32_t             blockDimZ_      = {},
                                          uint32_t             sharedMemBytes_ = {},
                                          size_t               paramCount_     = {},
                                          void const * const * pParams_        = {},
                                          size_t               extraCount_     = {},
                                          void const * const * pExtras_        = {},
                                          void const *         pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , function{ function_ }
      , gridDimX{ gridDimX_ }
      , gridDimY{ gridDimY_ }
      , gridDimZ{ gridDimZ_ }
      , blockDimX{ blockDimX_ }
      , blockDimY{ blockDimY_ }
      , blockDimZ{ blockDimZ_ }
      , sharedMemBytes{ sharedMemBytes_ }
      , paramCount{ paramCount_ }
      , pParams{ pParams_ }
      , extraCount{ extraCount_ }
      , pExtras{ pExtras_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CuLaunchInfoNVX( CuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CuLaunchInfoNVX( VkCuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT : CuLaunchInfoNVX( *reinterpret_cast<CuLaunchInfoNVX const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CuLaunchInfoNVX( CuFunctionNVX                                       function_,
                     uint32_t                                            gridDimX_,
                     uint32_t                                            gridDimY_,
                     uint32_t                                            gridDimZ_,
                     uint32_t                                            blockDimX_,
                     uint32_t                                            blockDimY_,
                     uint32_t                                            blockDimZ_,
                     uint32_t                                            sharedMemBytes_,
                     ArrayProxyNoTemporaries<void const * const> const & params_,
                     ArrayProxyNoTemporaries<void const * const> const & extras_ = {},
                     void const *                                        pNext_  = nullptr )
      : pNext( pNext_ )
      , function( function_ )
      , gridDimX( gridDimX_ )
      , gridDimY( gridDimY_ )
      , gridDimZ( gridDimZ_ )
      , blockDimX( blockDimX_ )
      , blockDimY( blockDimY_ )
      , blockDimZ( blockDimZ_ )
      , sharedMemBytes( sharedMemBytes_ )
      , paramCount( params_.size() )
      , pParams( params_.data() )
      , extraCount( extras_.size() )
      , pExtras( extras_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CuLaunchInfoNVX & operator=( CuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CuLaunchInfoNVX & operator=( VkCuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CuLaunchInfoNVX const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setFunction( CuFunctionNVX function_ ) & VULKAN_HPP_NOEXCEPT
    {
      function = function_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setFunction( CuFunctionNVX function_ ) && VULKAN_HPP_NOEXCEPT
    {
      function = function_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setGridDimX( uint32_t gridDimX_ ) & VULKAN_HPP_NOEXCEPT
    {
      gridDimX = gridDimX_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setGridDimX( uint32_t gridDimX_ ) && VULKAN_HPP_NOEXCEPT
    {
      gridDimX = gridDimX_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setGridDimY( uint32_t gridDimY_ ) & VULKAN_HPP_NOEXCEPT
    {
      gridDimY = gridDimY_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setGridDimY( uint32_t gridDimY_ ) && VULKAN_HPP_NOEXCEPT
    {
      gridDimY = gridDimY_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setGridDimZ( uint32_t gridDimZ_ ) & VULKAN_HPP_NOEXCEPT
    {
      gridDimZ = gridDimZ_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setGridDimZ( uint32_t gridDimZ_ ) && VULKAN_HPP_NOEXCEPT
    {
      gridDimZ = gridDimZ_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setBlockDimX( uint32_t blockDimX_ ) & VULKAN_HPP_NOEXCEPT
    {
      blockDimX = blockDimX_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setBlockDimX( uint32_t blockDimX_ ) && VULKAN_HPP_NOEXCEPT
    {
      blockDimX = blockDimX_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setBlockDimY( uint32_t blockDimY_ ) & VULKAN_HPP_NOEXCEPT
    {
      blockDimY = blockDimY_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setBlockDimY( uint32_t blockDimY_ ) && VULKAN_HPP_NOEXCEPT
    {
      blockDimY = blockDimY_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setBlockDimZ( uint32_t blockDimZ_ ) & VULKAN_HPP_NOEXCEPT
    {
      blockDimZ = blockDimZ_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setBlockDimZ( uint32_t blockDimZ_ ) && VULKAN_HPP_NOEXCEPT
    {
      blockDimZ = blockDimZ_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setSharedMemBytes( uint32_t sharedMemBytes_ ) & VULKAN_HPP_NOEXCEPT
    {
      sharedMemBytes = sharedMemBytes_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setSharedMemBytes( uint32_t sharedMemBytes_ ) && VULKAN_HPP_NOEXCEPT
    {
      sharedMemBytes = sharedMemBytes_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setParamCount( size_t paramCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      paramCount = paramCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setParamCount( size_t paramCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      paramCount = paramCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setPParams( void const * const * pParams_ ) & VULKAN_HPP_NOEXCEPT
    {
      pParams = pParams_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setPParams( void const * const * pParams_ ) && VULKAN_HPP_NOEXCEPT
    {
      pParams = pParams_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CuLaunchInfoNVX & setParams( ArrayProxyNoTemporaries<void const * const> const & params_ ) VULKAN_HPP_NOEXCEPT
    {
      paramCount = params_.size();
      pParams    = params_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setExtraCount( size_t extraCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      extraCount = extraCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setExtraCount( size_t extraCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      extraCount = extraCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setPExtras( void const * const * pExtras_ ) & VULKAN_HPP_NOEXCEPT
    {
      pExtras = pExtras_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setPExtras( void const * const * pExtras_ ) && VULKAN_HPP_NOEXCEPT
    {
      pExtras = pExtras_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CuLaunchInfoNVX & setExtras( ArrayProxyNoTemporaries<void const * const> const & extras_ ) VULKAN_HPP_NOEXCEPT
    {
      extraCount = extras_.size();
      pExtras    = extras_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCuLaunchInfoNVX const *>( this );
    }

    operator VkCuLaunchInfoNVX &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCuLaunchInfoNVX *>( this );
    }

    operator VkCuLaunchInfoNVX const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCuLaunchInfoNVX const *>( this );
    }

    operator VkCuLaunchInfoNVX *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCuLaunchInfoNVX *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               CuFunctionNVX const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               size_t const &,
               void const * const * const &,
               size_t const &,
               void const * const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie(
        sType, pNext, function, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, paramCount, pParams, extraCount, pExtras );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CuLaunchInfoNVX const & ) const = default;
#else
    bool operator==( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) &&
             ( gridDimZ == rhs.gridDimZ ) && ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) &&
             ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) && ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) &&
             ( pExtras == rhs.pExtras );
#  endif
    }

    bool operator!=( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType        sType          = StructureType::eCuLaunchInfoNVX;
    void const *         pNext          = {};
    CuFunctionNVX        function       = {};
    uint32_t             gridDimX       = {};
    uint32_t             gridDimY       = {};
    uint32_t             gridDimZ       = {};
    uint32_t             blockDimX      = {};
    uint32_t             blockDimY      = {};
    uint32_t             blockDimZ      = {};
    uint32_t             sharedMemBytes = {};
    size_t               paramCount     = {};
    void const * const * pParams        = {};
    size_t               extraCount     = {};
    void const * const * pExtras        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCuLaunchInfoNVX>
  {
    using Type = CuLaunchInfoNVX;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCuLaunchInfoNVX>
  {
    using Type = CuLaunchInfoNVX;
  };

  // wrapper struct for struct VkCuModuleCreateInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleCreateInfoNVX.html
  struct CuModuleCreateInfoNVX
  {
    using NativeType = VkCuModuleCreateInfoNVX;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCuModuleCreateInfoNVX;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CuModuleCreateInfoNVX( size_t dataSize_ = {}, void const * pData_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , dataSize{ dataSize_ }
      , pData{ pData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CuModuleCreateInfoNVX( CuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CuModuleCreateInfoNVX( VkCuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
      : CuModuleCreateInfoNVX( *reinterpret_cast<CuModuleCreateInfoNVX const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    CuModuleCreateInfoNVX( ArrayProxyNoTemporaries<T const> const & data_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CuModuleCreateInfoNVX & operator=( CuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CuModuleCreateInfoNVX & operator=( VkCuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CuModuleCreateInfoNVX const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX & setPData( void const * pData_ ) & VULKAN_HPP_NOEXCEPT
    {
      pData = pData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX && setPData( void const * pData_ ) && VULKAN_HPP_NOEXCEPT
    {
      pData = pData_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    CuModuleCreateInfoNVX & setData( ArrayProxyNoTemporaries<T const> const & data_ ) VULKAN_HPP_NOEXCEPT
    {
      dataSize = data_.size() * sizeof( T );
      pData    = data_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCuModuleCreateInfoNVX const *>( this );
    }

    operator VkCuModuleCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCuModuleCreateInfoNVX *>( this );
    }

    operator VkCuModuleCreateInfoNVX const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCuModuleCreateInfoNVX const *>( this );
    }

    operator VkCuModuleCreateInfoNVX *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCuModuleCreateInfoNVX *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, size_t const &, void const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, dataSize, pData );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CuModuleCreateInfoNVX const & ) const = default;
#else
    bool operator==( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
#  endif
    }

    bool operator!=( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType    = StructureType::eCuModuleCreateInfoNVX;
    void const *  pNext    = {};
    size_t        dataSize = {};
    void const *  pData    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCuModuleCreateInfoNVX>
  {
    using Type = CuModuleCreateInfoNVX;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCuModuleCreateInfoNVX>
  {
    using Type = CuModuleCreateInfoNVX;
  };

  // wrapper struct for struct VkCuModuleTexturingModeCreateInfoNVX, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleTexturingModeCreateInfoNVX.html
  struct CuModuleTexturingModeCreateInfoNVX
  {
    using NativeType = VkCuModuleTexturingModeCreateInfoNVX;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCuModuleTexturingModeCreateInfoNVX;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CuModuleTexturingModeCreateInfoNVX( Bool32 use64bitTexturing_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , use64bitTexturing{ use64bitTexturing_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CuModuleTexturingModeCreateInfoNVX( CuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CuModuleTexturingModeCreateInfoNVX( VkCuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
      : CuModuleTexturingModeCreateInfoNVX( *reinterpret_cast<CuModuleTexturingModeCreateInfoNVX const *>( &rhs ) )
    {
    }

    CuModuleTexturingModeCreateInfoNVX & operator=( CuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CuModuleTexturingModeCreateInfoNVX & operator=( VkCuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CuModuleTexturingModeCreateInfoNVX const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX & setUse64bitTexturing( Bool32 use64bitTexturing_ ) & VULKAN_HPP_NOEXCEPT
    {
      use64bitTexturing = use64bitTexturing_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX && setUse64bitTexturing( Bool32 use64bitTexturing_ ) && VULKAN_HPP_NOEXCEPT
    {
      use64bitTexturing = use64bitTexturing_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCuModuleTexturingModeCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCuModuleTexturingModeCreateInfoNVX const *>( this );
    }

    operator VkCuModuleTexturingModeCreateInfoNVX &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCuModuleTexturingModeCreateInfoNVX *>( this );
    }

    operator VkCuModuleTexturingModeCreateInfoNVX const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCuModuleTexturingModeCreateInfoNVX const *>( this );
    }

    operator VkCuModuleTexturingModeCreateInfoNVX *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCuModuleTexturingModeCreateInfoNVX *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, use64bitTexturing );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CuModuleTexturingModeCreateInfoNVX const & ) const = default;
#else
    bool operator==( CuModuleTexturingModeCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( use64bitTexturing == rhs.use64bitTexturing );
#  endif
    }

    bool operator!=( CuModuleTexturingModeCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType             = StructureType::eCuModuleTexturingModeCreateInfoNVX;
    void const *  pNext             = {};
    Bool32        use64bitTexturing = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCuModuleTexturingModeCreateInfoNVX>
  {
    using Type = CuModuleTexturingModeCreateInfoNVX;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCuModuleTexturingModeCreateInfoNVX>
  {
    using Type = CuModuleTexturingModeCreateInfoNVX;
  };

#if defined( VK_ENABLE_BETA_EXTENSIONS )
  // wrapper struct for struct VkCudaFunctionCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionCreateInfoNV.html
  struct CudaFunctionCreateInfoNV
  {
    using NativeType = VkCudaFunctionCreateInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCudaFunctionCreateInfoNV;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CudaFunctionCreateInfoNV( CudaModuleNV module_ = {}, char const * pName_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , module{ module_ }
      , pName{ pName_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CudaFunctionCreateInfoNV( CudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CudaFunctionCreateInfoNV( VkCudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : CudaFunctionCreateInfoNV( *reinterpret_cast<CudaFunctionCreateInfoNV const *>( &rhs ) )
    {
    }

    CudaFunctionCreateInfoNV & operator=( CudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CudaFunctionCreateInfoNV & operator=( VkCudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CudaFunctionCreateInfoNV const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV & setModule( CudaModuleNV module_ ) & VULKAN_HPP_NOEXCEPT
    {
      module = module_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV && setModule( CudaModuleNV module_ ) && VULKAN_HPP_NOEXCEPT
    {
      module = module_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV & setPName( char const * pName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pName = pName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV && setPName( char const * pName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pName = pName_;
      return std::move( *this );
    }
#  endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCudaFunctionCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCudaFunctionCreateInfoNV const *>( this );
    }

    operator VkCudaFunctionCreateInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCudaFunctionCreateInfoNV *>( this );
    }

    operator VkCudaFunctionCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCudaFunctionCreateInfoNV const *>( this );
    }

    operator VkCudaFunctionCreateInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCudaFunctionCreateInfoNV *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, CudaModuleNV const &, char const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, module, pName );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( CudaFunctionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( auto cmp = module <=> rhs.module; cmp != 0 )
        return cmp;
      if ( pName != rhs.pName )
        if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;

      return std::strong_ordering::equivalent;
    }
#  endif

    bool operator==( CudaFunctionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) );
    }

    bool operator!=( CudaFunctionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType sType  = StructureType::eCudaFunctionCreateInfoNV;
    void const *  pNext  = {};
    CudaModuleNV  module = {};
    char const *  pName  = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCudaFunctionCreateInfoNV>
  {
    using Type = CudaFunctionCreateInfoNV;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eCudaFunctionCreateInfoNV>
  {
    using Type = CudaFunctionCreateInfoNV;
  };
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

#if defined( VK_ENABLE_BETA_EXTENSIONS )
  // wrapper struct for struct VkCudaLaunchInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaLaunchInfoNV.html
  struct CudaLaunchInfoNV
  {
    using NativeType = VkCudaLaunchInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCudaLaunchInfoNV;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CudaLaunchInfoNV( CudaFunctionNV       function_       = {},
                                           uint32_t             gridDimX_       = {},
                                           uint32_t             gridDimY_       = {},
                                           uint32_t             gridDimZ_       = {},
                                           uint32_t             blockDimX_      = {},
                                           uint32_t             blockDimY_      = {},
                                           uint32_t             blockDimZ_      = {},
                                           uint32_t             sharedMemBytes_ = {},
                                           size_t               paramCount_     = {},
                                           void const * const * pParams_        = {},
                                           size_t               extraCount_     = {},
                                           void const * const * pExtras_        = {},
                                           void const *         pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , function{ function_ }
      , gridDimX{ gridDimX_ }
      , gridDimY{ gridDimY_ }
      , gridDimZ{ gridDimZ_ }
      , blockDimX{ blockDimX_ }
      , blockDimY{ blockDimY_ }
      , blockDimZ{ blockDimZ_ }
      , sharedMemBytes{ sharedMemBytes_ }
      , paramCount{ paramCount_ }
      , pParams{ pParams_ }
      , extraCount{ extraCount_ }
      , pExtras{ pExtras_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CudaLaunchInfoNV( CudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CudaLaunchInfoNV( VkCudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT : CudaLaunchInfoNV( *reinterpret_cast<CudaLaunchInfoNV const *>( &rhs ) ) {}

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CudaLaunchInfoNV( CudaFunctionNV                                      function_,
                      uint32_t                                            gridDimX_,
                      uint32_t                                            gridDimY_,
                      uint32_t                                            gridDimZ_,
                      uint32_t                                            blockDimX_,
                      uint32_t                                            blockDimY_,
                      uint32_t                                            blockDimZ_,
                      uint32_t                                            sharedMemBytes_,
                      ArrayProxyNoTemporaries<void const * const> const & params_,
                      ArrayProxyNoTemporaries<void const * const> const & extras_ = {},
                      void const *                                        pNext_  = nullptr )
      : pNext( pNext_ )
      , function( function_ )
      , gridDimX( gridDimX_ )
      , gridDimY( gridDimY_ )
      , gridDimZ( gridDimZ_ )
      , blockDimX( blockDimX_ )
      , blockDimY( blockDimY_ )
      , blockDimZ( blockDimZ_ )
      , sharedMemBytes( sharedMemBytes_ )
      , paramCount( params_.size() )
      , pParams( params_.data() )
      , extraCount( extras_.size() )
      , pExtras( extras_.data() )
    {
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CudaLaunchInfoNV & operator=( CudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CudaLaunchInfoNV & operator=( VkCudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CudaLaunchInfoNV const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setFunction( CudaFunctionNV function_ ) & VULKAN_HPP_NOEXCEPT
    {
      function = function_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setFunction( CudaFunctionNV function_ ) && VULKAN_HPP_NOEXCEPT
    {
      function = function_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setGridDimX( uint32_t gridDimX_ ) & VULKAN_HPP_NOEXCEPT
    {
      gridDimX = gridDimX_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setGridDimX( uint32_t gridDimX_ ) && VULKAN_HPP_NOEXCEPT
    {
      gridDimX = gridDimX_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setGridDimY( uint32_t gridDimY_ ) & VULKAN_HPP_NOEXCEPT
    {
      gridDimY = gridDimY_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setGridDimY( uint32_t gridDimY_ ) && VULKAN_HPP_NOEXCEPT
    {
      gridDimY = gridDimY_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setGridDimZ( uint32_t gridDimZ_ ) & VULKAN_HPP_NOEXCEPT
    {
      gridDimZ = gridDimZ_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setGridDimZ( uint32_t gridDimZ_ ) && VULKAN_HPP_NOEXCEPT
    {
      gridDimZ = gridDimZ_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setBlockDimX( uint32_t blockDimX_ ) & VULKAN_HPP_NOEXCEPT
    {
      blockDimX = blockDimX_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setBlockDimX( uint32_t blockDimX_ ) && VULKAN_HPP_NOEXCEPT
    {
      blockDimX = blockDimX_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setBlockDimY( uint32_t blockDimY_ ) & VULKAN_HPP_NOEXCEPT
    {
      blockDimY = blockDimY_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setBlockDimY( uint32_t blockDimY_ ) && VULKAN_HPP_NOEXCEPT
    {
      blockDimY = blockDimY_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setBlockDimZ( uint32_t blockDimZ_ ) & VULKAN_HPP_NOEXCEPT
    {
      blockDimZ = blockDimZ_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setBlockDimZ( uint32_t blockDimZ_ ) && VULKAN_HPP_NOEXCEPT
    {
      blockDimZ = blockDimZ_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setSharedMemBytes( uint32_t sharedMemBytes_ ) & VULKAN_HPP_NOEXCEPT
    {
      sharedMemBytes = sharedMemBytes_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setSharedMemBytes( uint32_t sharedMemBytes_ ) && VULKAN_HPP_NOEXCEPT
    {
      sharedMemBytes = sharedMemBytes_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setParamCount( size_t paramCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      paramCount = paramCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setParamCount( size_t paramCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      paramCount = paramCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setPParams( void const * const * pParams_ ) & VULKAN_HPP_NOEXCEPT
    {
      pParams = pParams_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setPParams( void const * const * pParams_ ) && VULKAN_HPP_NOEXCEPT
    {
      pParams = pParams_;
      return std::move( *this );
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CudaLaunchInfoNV & setParams( ArrayProxyNoTemporaries<void const * const> const & params_ ) VULKAN_HPP_NOEXCEPT
    {
      paramCount = params_.size();
      pParams    = params_.data();
      return *this;
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setExtraCount( size_t extraCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      extraCount = extraCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setExtraCount( size_t extraCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      extraCount = extraCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setPExtras( void const * const * pExtras_ ) & VULKAN_HPP_NOEXCEPT
    {
      pExtras = pExtras_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setPExtras( void const * const * pExtras_ ) && VULKAN_HPP_NOEXCEPT
    {
      pExtras = pExtras_;
      return std::move( *this );
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CudaLaunchInfoNV & setExtras( ArrayProxyNoTemporaries<void const * const> const & extras_ ) VULKAN_HPP_NOEXCEPT
    {
      extraCount = extras_.size();
      pExtras    = extras_.data();
      return *this;
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#  endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCudaLaunchInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCudaLaunchInfoNV const *>( this );
    }

    operator VkCudaLaunchInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCudaLaunchInfoNV *>( this );
    }

    operator VkCudaLaunchInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCudaLaunchInfoNV const *>( this );
    }

    operator VkCudaLaunchInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCudaLaunchInfoNV *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               CudaFunctionNV const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               size_t const &,
               void const * const * const &,
               size_t const &,
               void const * const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie(
        sType, pNext, function, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, paramCount, pParams, extraCount, pExtras );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CudaLaunchInfoNV const & ) const = default;
#  else
    bool operator==( CudaLaunchInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) &&
             ( gridDimZ == rhs.gridDimZ ) && ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) &&
             ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) && ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) &&
             ( pExtras == rhs.pExtras );
#    endif
    }

    bool operator!=( CudaLaunchInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType        sType          = StructureType::eCudaLaunchInfoNV;
    void const *         pNext          = {};
    CudaFunctionNV       function       = {};
    uint32_t             gridDimX       = {};
    uint32_t             gridDimY       = {};
    uint32_t             gridDimZ       = {};
    uint32_t             blockDimX      = {};
    uint32_t             blockDimY      = {};
    uint32_t             blockDimZ      = {};
    uint32_t             sharedMemBytes = {};
    size_t               paramCount     = {};
    void const * const * pParams        = {};
    size_t               extraCount     = {};
    void const * const * pExtras        = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCudaLaunchInfoNV>
  {
    using Type = CudaLaunchInfoNV;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eCudaLaunchInfoNV>
  {
    using Type = CudaLaunchInfoNV;
  };
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

#if defined( VK_ENABLE_BETA_EXTENSIONS )
  // wrapper struct for struct VkCudaModuleCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleCreateInfoNV.html
  struct CudaModuleCreateInfoNV
  {
    using NativeType = VkCudaModuleCreateInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCudaModuleCreateInfoNV;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CudaModuleCreateInfoNV( size_t dataSize_ = {}, void const * pData_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , dataSize{ dataSize_ }
      , pData{ pData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CudaModuleCreateInfoNV( CudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CudaModuleCreateInfoNV( VkCudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : CudaModuleCreateInfoNV( *reinterpret_cast<CudaModuleCreateInfoNV const *>( &rhs ) )
    {
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    CudaModuleCreateInfoNV( ArrayProxyNoTemporaries<T const> const & data_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() )
    {
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CudaModuleCreateInfoNV & operator=( CudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CudaModuleCreateInfoNV & operator=( VkCudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CudaModuleCreateInfoNV const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV & setPData( void const * pData_ ) & VULKAN_HPP_NOEXCEPT
    {
      pData = pData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV && setPData( void const * pData_ ) && VULKAN_HPP_NOEXCEPT
    {
      pData = pData_;
      return std::move( *this );
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    CudaModuleCreateInfoNV & setData( ArrayProxyNoTemporaries<T const> const & data_ ) VULKAN_HPP_NOEXCEPT
    {
      dataSize = data_.size() * sizeof( T );
      pData    = data_.data();
      return *this;
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#  endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkCudaModuleCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCudaModuleCreateInfoNV const *>( this );
    }

    operator VkCudaModuleCreateInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCudaModuleCreateInfoNV *>( this );
    }

    operator VkCudaModuleCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCudaModuleCreateInfoNV const *>( this );
    }

    operator VkCudaModuleCreateInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCudaModuleCreateInfoNV *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, size_t const &, void const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, dataSize, pData );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CudaModuleCreateInfoNV const & ) const = default;
#  else
    bool operator==( CudaModuleCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
#    endif
    }

    bool operator!=( CudaModuleCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType sType    = StructureType::eCudaModuleCreateInfoNV;
    void const *  pNext    = {};
    size_t        dataSize = {};
    void const *  pData    = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCudaModuleCreateInfoNV>
  {
    using Type = CudaModuleCreateInfoNV;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eCudaModuleCreateInfoNV>
  {
    using Type = CudaModuleCreateInfoNV;
  };
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

  // wrapper struct for struct VkCustomResolveCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCustomResolveCreateInfoEXT.html
  struct CustomResolveCreateInfoEXT
  {
    using NativeType = VkCustomResolveCreateInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCustomResolveCreateInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR CustomResolveCreateInfoEXT( Bool32         customResolve_           = {},
                                                     uint32_t       colorAttachmentCount_    = {},
                                                     Format const * pColorAttachmentFormats_ = {},
                                                     Format         depthAttachmentFormat_   = Format::eUndefined,
                                                     Format         stencilAttachmentFormat_ = Format::eUndefined,
                                                     void const *   pNext_                   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , customResolve{ customResolve_ }
      , colorAttachmentCount{ colorAttachmentCount_ }
      , pColorAttachmentFormats{ pColorAttachmentFormats_ }
      , depthAttachmentFormat{ depthAttachmentFormat_ }
      , stencilAttachmentFormat{ stencilAttachmentFormat_ }
    {
    }

    VULKAN_HPP_CONSTEXPR CustomResolveCreateInfoEXT( CustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    CustomResolveCreateInfoEXT( VkCustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : CustomResolveCreateInfoEXT( *reinterpret_cast<CustomResolveCreateInfoEXT const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CustomResolveCreateInfoEXT( Bool32                                        customResolve_,
                                ArrayProxyNoTemporaries<Format const> const & colorAttachmentFormats_,
                                Format                                        depthAttachmentFormat_   = Format::eUndefined,
                                Format                                        stencilAttachmentFormat_ = Format::eUndefined,
                                void const *                                  pNext_                   = nullptr )
      : pNext( pNext_ )
      , customResolve( customResolve_ )
      , colorAttachmentCount( static_cast<uint32_t>( colorAttachmentFormats_.size() ) )
      , pColorAttachmentFormats( colorAttachmentFormats_.data() )
      , depthAttachmentFormat( depthAttachmentFormat_ )
      , stencilAttachmentFormat( stencilAttachmentFormat_ )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    CustomResolveCreateInfoEXT & operator=( CustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    CustomResolveCreateInfoEXT & operator=( VkCustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<CustomResolveCreateInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setCustomResolve( Bool32 customResolve_ ) & VULKAN_HPP_NOEXCEPT
    {
      customResolve = customResolve_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setCustomResolve( Bool32 customResolve_ ) && VULKAN_HPP_NOEXCEPT
    {
      customResolve = customResolve_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      colorAttachmentCount = colorAttachmentCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      colorAttachmentCount = colorAttachmentCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setPColorAttachmentFormats( Format const * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT
    {
      pColorAttachmentFormats = pColorAttachmentFormats_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setPColorAttachmentFormats( Format const * pColorAttachmentFormats_ ) && VULKAN_HPP_NOEXCEPT
    {
      pColorAttachmentFormats = pColorAttachmentFormats_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    CustomResolveCreateInfoEXT & setColorAttachmentFormats( ArrayProxyNoTemporaries<Format const> const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT
    {
      colorAttachmentCount    = static_cast<uint32_t>( colorAttachmentFormats_.size() );
      pColorAttachmentFormats = colorAttachmentFormats_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthAttachmentFormat = depthAttachmentFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthAttachmentFormat = depthAttachmentFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      stencilAttachmentFormat = stencilAttachmentFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      stencilAttachmentFormat = stencilAttachmentFormat_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkCustomResolveCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCustomResolveCreateInfoEXT const *>( this );
    }

    operator VkCustomResolveCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkCustomResolveCreateInfoEXT *>( this );
    }

    operator VkCustomResolveCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCustomResolveCreateInfoEXT const *>( this );
    }

    operator VkCustomResolveCreateInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkCustomResolveCreateInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &, uint32_t const &, Format const * const &, Format const &, Format const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, customResolve, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( CustomResolveCreateInfoEXT const & ) const = default;
#else
    bool operator==( CustomResolveCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customResolve == rhs.customResolve ) &&
             ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) &&
             ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && ( stencilAttachmentFormat == rhs.stencilAttachmentFormat );
#  endif
    }

    bool operator!=( CustomResolveCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType  sType                   = StructureType::eCustomResolveCreateInfoEXT;
    void const *   pNext                   = {};
    Bool32         customResolve           = {};
    uint32_t       colorAttachmentCount    = {};
    Format const * pColorAttachmentFormats = {};
    Format         depthAttachmentFormat   = Format::eUndefined;
    Format         stencilAttachmentFormat = Format::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkCustomResolveCreateInfoEXT>
  {
    using Type = CustomResolveCreateInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eCustomResolveCreateInfoEXT>
  {
    using Type = CustomResolveCreateInfoEXT;
  };

#if defined( VK_USE_PLATFORM_WIN32_KHR )
  // wrapper struct for struct VkD3D12FenceSubmitInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkD3D12FenceSubmitInfoKHR.html
  struct D3D12FenceSubmitInfoKHR
  {
    using NativeType = VkD3D12FenceSubmitInfoKHR;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eD3D12FenceSubmitInfoKHR;

#  if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t         waitSemaphoreValuesCount_   = {},
                                                  uint64_t const * pWaitSemaphoreValues_       = {},
                                                  uint32_t         signalSemaphoreValuesCount_ = {},
                                                  uint64_t const * pSignalSemaphoreValues_     = {},
                                                  void const *     pNext_                      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , waitSemaphoreValuesCount{ waitSemaphoreValuesCount_ }
      , pWaitSemaphoreValues{ pWaitSemaphoreValues_ }
      , signalSemaphoreValuesCount{ signalSemaphoreValuesCount_ }
      , pSignalSemaphoreValues{ pSignalSemaphoreValues_ }
    {
    }

    VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
      : D3D12FenceSubmitInfoKHR( *reinterpret_cast<D3D12FenceSubmitInfoKHR const *>( &rhs ) )
    {
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    D3D12FenceSubmitInfoKHR( ArrayProxyNoTemporaries<uint64_t const> const & waitSemaphoreValues_,
                             ArrayProxyNoTemporaries<uint64_t const> const & signalSemaphoreValues_ = {},
                             void const *                                    pNext_                 = nullptr )
      : pNext( pNext_ )
      , waitSemaphoreValuesCount( static_cast<uint32_t>( waitSemaphoreValues_.size() ) )
      , pWaitSemaphoreValues( waitSemaphoreValues_.data() )
      , signalSemaphoreValuesCount( static_cast<uint32_t>( signalSemaphoreValues_.size() ) )
      , pSignalSemaphoreValues( signalSemaphoreValues_.data() )
    {
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    D3D12FenceSubmitInfoKHR & operator=( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#  endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    D3D12FenceSubmitInfoKHR & operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<D3D12FenceSubmitInfoKHR const *>( &rhs );
      return *this;
    }

#  if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      waitSemaphoreValuesCount = waitSemaphoreValuesCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      waitSemaphoreValuesCount = waitSemaphoreValuesCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setPWaitSemaphoreValues( uint64_t const * pWaitSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT
    {
      pWaitSemaphoreValues = pWaitSemaphoreValues_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setPWaitSemaphoreValues( uint64_t const * pWaitSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT
    {
      pWaitSemaphoreValues = pWaitSemaphoreValues_;
      return std::move( *this );
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    D3D12FenceSubmitInfoKHR & setWaitSemaphoreValues( ArrayProxyNoTemporaries<uint64_t const> const & waitSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT
    {
      waitSemaphoreValuesCount = static_cast<uint32_t>( waitSemaphoreValues_.size() );
      pWaitSemaphoreValues     = waitSemaphoreValues_.data();
      return *this;
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      signalSemaphoreValuesCount = signalSemaphoreValuesCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      signalSemaphoreValuesCount = signalSemaphoreValuesCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setPSignalSemaphoreValues( uint64_t const * pSignalSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSignalSemaphoreValues = pSignalSemaphoreValues_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setPSignalSemaphoreValues( uint64_t const * pSignalSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSignalSemaphoreValues = pSignalSemaphoreValues_;
      return std::move( *this );
    }

#    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    D3D12FenceSubmitInfoKHR & setSignalSemaphoreValues( ArrayProxyNoTemporaries<uint64_t const> const & signalSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT
    {
      signalSemaphoreValuesCount = static_cast<uint32_t>( signalSemaphoreValues_.size() );
      pSignalSemaphoreValues     = signalSemaphoreValues_.data();
      return *this;
    }
#    endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#  endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR const *>( this );
    }

    operator VkD3D12FenceSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>( this );
    }

    operator VkD3D12FenceSubmitInfoKHR const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkD3D12FenceSubmitInfoKHR const *>( this );
    }

    operator VkD3D12FenceSubmitInfoKHR *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>( this );
    }

#  if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, uint64_t const * const &, uint32_t const &, uint64_t const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, waitSemaphoreValuesCount, pWaitSemaphoreValues, signalSemaphoreValuesCount, pSignalSemaphoreValues );
    }
#  endif

#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( D3D12FenceSubmitInfoKHR const & ) const = default;
#  else
    bool operator==( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#    if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#    else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) &&
             ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) &&
             ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
#    endif
    }

    bool operator!=( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#  endif

  public:
    StructureType    sType                      = StructureType::eD3D12FenceSubmitInfoKHR;
    void const *     pNext                      = {};
    uint32_t         waitSemaphoreValuesCount   = {};
    uint64_t const * pWaitSemaphoreValues       = {};
    uint32_t         signalSemaphoreValuesCount = {};
    uint64_t const * pSignalSemaphoreValues     = {};
  };

#  if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkD3D12FenceSubmitInfoKHR>
  {
    using Type = D3D12FenceSubmitInfoKHR;
  };
#  endif

  template <>
  struct CppType<StructureType, StructureType::eD3D12FenceSubmitInfoKHR>
  {
    using Type = D3D12FenceSubmitInfoKHR;
  };
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

  // wrapper struct for struct VkDataGraphOpticalFlowImageFormatInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowImageFormatInfoARM.html
  struct DataGraphOpticalFlowImageFormatInfoARM
  {
    using NativeType = VkDataGraphOpticalFlowImageFormatInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphOpticalFlowImageFormatInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphOpticalFlowImageFormatInfoARM( DataGraphOpticalFlowImageUsageFlagsARM usage_ = {},
                                                                 void const *                           pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , usage{ usage_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphOpticalFlowImageFormatInfoARM( DataGraphOpticalFlowImageFormatInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphOpticalFlowImageFormatInfoARM( VkDataGraphOpticalFlowImageFormatInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphOpticalFlowImageFormatInfoARM( *reinterpret_cast<DataGraphOpticalFlowImageFormatInfoARM const *>( &rhs ) )
    {
    }

    DataGraphOpticalFlowImageFormatInfoARM & operator=( DataGraphOpticalFlowImageFormatInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphOpticalFlowImageFormatInfoARM & operator=( VkDataGraphOpticalFlowImageFormatInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphOpticalFlowImageFormatInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphOpticalFlowImageFormatInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphOpticalFlowImageFormatInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphOpticalFlowImageFormatInfoARM & setUsage( DataGraphOpticalFlowImageUsageFlagsARM usage_ ) & VULKAN_HPP_NOEXCEPT
    {
      usage = usage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphOpticalFlowImageFormatInfoARM && setUsage( DataGraphOpticalFlowImageUsageFlagsARM usage_ ) && VULKAN_HPP_NOEXCEPT
    {
      usage = usage_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphOpticalFlowImageFormatInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM const *>( this );
    }

    operator VkDataGraphOpticalFlowImageFormatInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM *>( this );
    }

    operator VkDataGraphOpticalFlowImageFormatInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM const *>( this );
    }

    operator VkDataGraphOpticalFlowImageFormatInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DataGraphOpticalFlowImageUsageFlagsARM const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, usage );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphOpticalFlowImageFormatInfoARM const & ) const = default;
#else
    bool operator==( DataGraphOpticalFlowImageFormatInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage );
#  endif
    }

    bool operator!=( DataGraphOpticalFlowImageFormatInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                          sType = StructureType::eDataGraphOpticalFlowImageFormatInfoARM;
    void const *                           pNext = {};
    DataGraphOpticalFlowImageUsageFlagsARM usage = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphOpticalFlowImageFormatInfoARM>
  {
    using Type = DataGraphOpticalFlowImageFormatInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphOpticalFlowImageFormatInfoARM>
  {
    using Type = DataGraphOpticalFlowImageFormatInfoARM;
  };

  // wrapper struct for struct VkDataGraphOpticalFlowImageFormatPropertiesARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowImageFormatPropertiesARM.html
  struct DataGraphOpticalFlowImageFormatPropertiesARM
  {
    using NativeType = VkDataGraphOpticalFlowImageFormatPropertiesARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphOpticalFlowImageFormatPropertiesARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphOpticalFlowImageFormatPropertiesARM( Format format_ = Format::eUndefined, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , format{ format_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphOpticalFlowImageFormatPropertiesARM( DataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphOpticalFlowImageFormatPropertiesARM( VkDataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphOpticalFlowImageFormatPropertiesARM( *reinterpret_cast<DataGraphOpticalFlowImageFormatPropertiesARM const *>( &rhs ) )
    {
    }

    DataGraphOpticalFlowImageFormatPropertiesARM & operator=( DataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphOpticalFlowImageFormatPropertiesARM & operator=( VkDataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphOpticalFlowImageFormatPropertiesARM const *>( &rhs );
      return *this;
    }

    operator VkDataGraphOpticalFlowImageFormatPropertiesARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphOpticalFlowImageFormatPropertiesARM const *>( this );
    }

    operator VkDataGraphOpticalFlowImageFormatPropertiesARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphOpticalFlowImageFormatPropertiesARM *>( this );
    }

    operator VkDataGraphOpticalFlowImageFormatPropertiesARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphOpticalFlowImageFormatPropertiesARM const *>( this );
    }

    operator VkDataGraphOpticalFlowImageFormatPropertiesARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphOpticalFlowImageFormatPropertiesARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, Format const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, format );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphOpticalFlowImageFormatPropertiesARM const & ) const = default;
#else
    bool operator==( DataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format );
#  endif
    }

    bool operator!=( DataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType  = StructureType::eDataGraphOpticalFlowImageFormatPropertiesARM;
    void *        pNext  = {};
    Format        format = Format::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphOpticalFlowImageFormatPropertiesARM>
  {
    using Type = DataGraphOpticalFlowImageFormatPropertiesARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphOpticalFlowImageFormatPropertiesARM>
  {
    using Type = DataGraphOpticalFlowImageFormatPropertiesARM;
  };

  // wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html
  struct PhysicalDeviceDataGraphOperationSupportARM
  {
    using NativeType = VkPhysicalDeviceDataGraphOperationSupportARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM(
      PhysicalDeviceDataGraphOperationTypeARM operationType_ = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet,
      std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const & name_    = {},
      uint32_t                                                                                version_ = {} ) VULKAN_HPP_NOEXCEPT
      : operationType{ operationType_ }
      , name{ name_ }
      , version{ version_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    PhysicalDeviceDataGraphOperationSupportARM( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : PhysicalDeviceDataGraphOperationSupportARM( *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationTypeARM operationType_, std::string const & name_, uint32_t version_ = {} )
      : operationType( operationType_ ), version( version_ )
    {
      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
#    if defined( _WIN32 )
      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
#    else
      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
#    endif
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    PhysicalDeviceDataGraphOperationSupportARM & operator=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    PhysicalDeviceDataGraphOperationSupportARM & operator=( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      operationType = operationType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM && setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      operationType = operationType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
      setName( std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      name = name_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &&
      setName( std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      name = name_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    PhysicalDeviceDataGraphOperationSupportARM & setName( std::string const & name_ ) VULKAN_HPP_NOEXCEPT
    {
      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
#    if defined( _WIN32 )
      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
#    else
      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
#    endif
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setVersion( uint32_t version_ ) & VULKAN_HPP_NOEXCEPT
    {
      version = version_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM && setVersion( uint32_t version_ ) && VULKAN_HPP_NOEXCEPT
    {
      version = version_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkPhysicalDeviceDataGraphOperationSupportARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM const *>( this );
    }

    operator VkPhysicalDeviceDataGraphOperationSupportARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
    }

    operator VkPhysicalDeviceDataGraphOperationSupportARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM const *>( this );
    }

    operator VkPhysicalDeviceDataGraphOperationSupportARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<PhysicalDeviceDataGraphOperationTypeARM const &,
               ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( operationType, name, version );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = operationType <=> rhs.operationType; cmp != 0 )
        return cmp;
      if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 )
        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
      if ( auto cmp = version <=> rhs.version; cmp != 0 )
        return cmp;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( operationType == rhs.operationType ) && ( strcmp( name, rhs.name ) == 0 ) && ( version == rhs.version );
    }

    bool operator!=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    PhysicalDeviceDataGraphOperationTypeARM operationType = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet;
    ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name    = {};
    uint32_t                                                                            version = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkPhysicalDeviceDataGraphOperationSupportARM>
  {
    using Type = PhysicalDeviceDataGraphOperationSupportARM;
  };
#endif

  // wrapper struct for struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineBuiltinModelCreateInfoQCOM.html
  struct DataGraphPipelineBuiltinModelCreateInfoQCOM
  {
    using NativeType = VkDataGraphPipelineBuiltinModelCreateInfoQCOM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM( PhysicalDeviceDataGraphOperationSupportARM const * pOperation_ = {},
                                                                         void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pOperation{ pOperation_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14
      DataGraphPipelineBuiltinModelCreateInfoQCOM( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineBuiltinModelCreateInfoQCOM( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineBuiltinModelCreateInfoQCOM( *reinterpret_cast<DataGraphPipelineBuiltinModelCreateInfoQCOM const *>( &rhs ) )
    {
    }

    DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineBuiltinModelCreateInfoQCOM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM & setPOperation( PhysicalDeviceDataGraphOperationSupportARM const * pOperation_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pOperation = pOperation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM && setPOperation( PhysicalDeviceDataGraphOperationSupportARM const * pOperation_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pOperation = pOperation_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM const *>( this );
    }

    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
    }

    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM const *>( this );
    }

    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, PhysicalDeviceDataGraphOperationSupportARM const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pOperation );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineBuiltinModelCreateInfoQCOM const & ) const = default;
#else
    bool operator==( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pOperation == rhs.pOperation );
#  endif
    }

    bool operator!=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                                      sType      = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM;
    void const *                                       pNext      = {};
    PhysicalDeviceDataGraphOperationSupportARM const * pOperation = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineBuiltinModelCreateInfoQCOM>
  {
    using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM>
  {
    using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM;
  };

  // wrapper struct for struct VkDataGraphPipelineCompilerControlCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineCompilerControlCreateInfoARM.html
  struct DataGraphPipelineCompilerControlCreateInfoARM
  {
    using NativeType = VkDataGraphPipelineCompilerControlCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineCompilerControlCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineCompilerControlCreateInfoARM( char const * pVendorOptions_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pVendorOptions{ pVendorOptions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineCompilerControlCreateInfoARM( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineCompilerControlCreateInfoARM( VkDataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineCompilerControlCreateInfoARM( *reinterpret_cast<DataGraphPipelineCompilerControlCreateInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineCompilerControlCreateInfoARM & operator=( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineCompilerControlCreateInfoARM & operator=( VkDataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineCompilerControlCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM & setPVendorOptions( char const * pVendorOptions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pVendorOptions = pVendorOptions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM && setPVendorOptions( char const * pVendorOptions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pVendorOptions = pVendorOptions_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineCompilerControlCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineCompilerControlCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineCompilerControlCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineCompilerControlCreateInfoARM *>( this );
    }

    operator VkDataGraphPipelineCompilerControlCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineCompilerControlCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineCompilerControlCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineCompilerControlCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, char const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pVendorOptions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( pVendorOptions != rhs.pVendorOptions )
        if ( auto cmp = strcmp( pVendorOptions, rhs.pVendorOptions ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
             ( ( pVendorOptions == rhs.pVendorOptions ) || ( strcmp( pVendorOptions, rhs.pVendorOptions ) == 0 ) );
    }

    bool operator!=( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType sType          = StructureType::eDataGraphPipelineCompilerControlCreateInfoARM;
    void const *  pNext          = {};
    char const *  pVendorOptions = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineCompilerControlCreateInfoARM>
  {
    using Type = DataGraphPipelineCompilerControlCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineCompilerControlCreateInfoARM>
  {
    using Type = DataGraphPipelineCompilerControlCreateInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineConstantARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineConstantARM.html
  struct DataGraphPipelineConstantARM
  {
    using NativeType = VkDataGraphPipelineConstantARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineConstantARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantARM( uint32_t id_ = {}, void const * pConstantData_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , id{ id_ }
      , pConstantData{ pConstantData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantARM( DataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineConstantARM( VkDataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineConstantARM( *reinterpret_cast<DataGraphPipelineConstantARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineConstantARM & operator=( DataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineConstantARM & operator=( VkDataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineConstantARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM & setId( uint32_t id_ ) & VULKAN_HPP_NOEXCEPT
    {
      id = id_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM && setId( uint32_t id_ ) && VULKAN_HPP_NOEXCEPT
    {
      id = id_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM & setPConstantData( void const * pConstantData_ ) & VULKAN_HPP_NOEXCEPT
    {
      pConstantData = pConstantData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM && setPConstantData( void const * pConstantData_ ) && VULKAN_HPP_NOEXCEPT
    {
      pConstantData = pConstantData_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineConstantARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineConstantARM const *>( this );
    }

    operator VkDataGraphPipelineConstantARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineConstantARM *>( this );
    }

    operator VkDataGraphPipelineConstantARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineConstantARM const *>( this );
    }

    operator VkDataGraphPipelineConstantARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineConstantARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, void const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, id, pConstantData );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineConstantARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineConstantARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( id == rhs.id ) && ( pConstantData == rhs.pConstantData );
#  endif
    }

    bool operator!=( DataGraphPipelineConstantARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType         = StructureType::eDataGraphPipelineConstantARM;
    void const *  pNext         = {};
    uint32_t      id            = {};
    void const *  pConstantData = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineConstantARM>
  {
    using Type = DataGraphPipelineConstantARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineConstantARM>
  {
    using Type = DataGraphPipelineConstantARM;
  };

  // wrapper struct for struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.html
  struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM
  {
    using NativeType = VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;

    static bool const                                  allowDuplicate = true;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( uint32_t     dimension_ = {},
                                                                                       uint32_t     zeroCount_ = {},
                                                                                       uint32_t     groupSize_ = {},
                                                                                       void const * pNext_     = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , dimension{ dimension_ }
      , zeroCount{ zeroCount_ }
      , groupSize{ groupSize_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM(
      DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs )
      VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM(
          *reinterpret_cast<DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM &
      operator=( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM &
      operator=( VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setDimension( uint32_t dimension_ ) & VULKAN_HPP_NOEXCEPT
    {
      dimension = dimension_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setDimension( uint32_t dimension_ ) && VULKAN_HPP_NOEXCEPT
    {
      dimension = dimension_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setZeroCount( uint32_t zeroCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      zeroCount = zeroCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setZeroCount( uint32_t zeroCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      zeroCount = zeroCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setGroupSize( uint32_t groupSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      groupSize = groupSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setGroupSize( uint32_t groupSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      groupSize = groupSize_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const *>( this );
    }

    operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *>( this );
    }

    operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const *>( this );
    }

    operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, dimension, zeroCount, groupSize );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dimension == rhs.dimension ) && ( zeroCount == rhs.zeroCount ) &&
             ( groupSize == rhs.groupSize );
#  endif
    }

    bool operator!=( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType     = StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;
    void const *  pNext     = {};
    uint32_t      dimension = {};
    uint32_t      zeroCount = {};
    uint32_t      groupSize = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM>
  {
    using Type = DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM>
  {
    using Type = DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineResourceInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineResourceInfoARM.html
  struct DataGraphPipelineResourceInfoARM
  {
    using NativeType = VkDataGraphPipelineResourceInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineResourceInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoARM( uint32_t     descriptorSet_ = {},
                                                           uint32_t     binding_       = {},
                                                           uint32_t     arrayElement_  = {},
                                                           void const * pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , descriptorSet{ descriptorSet_ }
      , binding{ binding_ }
      , arrayElement{ arrayElement_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoARM( DataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineResourceInfoARM( VkDataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineResourceInfoARM( *reinterpret_cast<DataGraphPipelineResourceInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineResourceInfoARM & operator=( DataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineResourceInfoARM & operator=( VkDataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineResourceInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setDescriptorSet( uint32_t descriptorSet_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorSet = descriptorSet_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setDescriptorSet( uint32_t descriptorSet_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorSet = descriptorSet_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT
    {
      binding = binding_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT
    {
      binding = binding_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setArrayElement( uint32_t arrayElement_ ) & VULKAN_HPP_NOEXCEPT
    {
      arrayElement = arrayElement_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setArrayElement( uint32_t arrayElement_ ) && VULKAN_HPP_NOEXCEPT
    {
      arrayElement = arrayElement_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineResourceInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineResourceInfoARM const *>( this );
    }

    operator VkDataGraphPipelineResourceInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineResourceInfoARM *>( this );
    }

    operator VkDataGraphPipelineResourceInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineResourceInfoARM const *>( this );
    }

    operator VkDataGraphPipelineResourceInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineResourceInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, descriptorSet, binding, arrayElement );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineResourceInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineResourceInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSet == rhs.descriptorSet ) && ( binding == rhs.binding ) &&
             ( arrayElement == rhs.arrayElement );
#  endif
    }

    bool operator!=( DataGraphPipelineResourceInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType         = StructureType::eDataGraphPipelineResourceInfoARM;
    void const *  pNext         = {};
    uint32_t      descriptorSet = {};
    uint32_t      binding       = {};
    uint32_t      arrayElement  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineResourceInfoARM>
  {
    using Type = DataGraphPipelineResourceInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineResourceInfoARM>
  {
    using Type = DataGraphPipelineResourceInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineCreateInfoARM.html
  struct DataGraphPipelineCreateInfoARM
  {
    using NativeType = VkDataGraphPipelineCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineCreateInfoARM( PipelineCreateFlags2                     flags_             = {},
                                                         PipelineLayout                           layout_            = {},
                                                         uint32_t                                 resourceInfoCount_ = {},
                                                         DataGraphPipelineResourceInfoARM const * pResourceInfos_    = {},
                                                         void const *                             pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , layout{ layout_ }
      , resourceInfoCount{ resourceInfoCount_ }
      , pResourceInfos{ pResourceInfos_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineCreateInfoARM( DataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineCreateInfoARM( VkDataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineCreateInfoARM( *reinterpret_cast<DataGraphPipelineCreateInfoARM const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphPipelineCreateInfoARM( PipelineCreateFlags2                                                    flags_,
                                    PipelineLayout                                                          layout_,
                                    ArrayProxyNoTemporaries<DataGraphPipelineResourceInfoARM const> const & resourceInfos_,
                                    void const *                                                            pNext_ = nullptr )
      : pNext( pNext_ )
      , flags( flags_ )
      , layout( layout_ )
      , resourceInfoCount( static_cast<uint32_t>( resourceInfos_.size() ) )
      , pResourceInfos( resourceInfos_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DataGraphPipelineCreateInfoARM & operator=( DataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineCreateInfoARM & operator=( VkDataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setFlags( PipelineCreateFlags2 flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setFlags( PipelineCreateFlags2 flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setResourceInfoCount( uint32_t resourceInfoCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      resourceInfoCount = resourceInfoCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setResourceInfoCount( uint32_t resourceInfoCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      resourceInfoCount = resourceInfoCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setPResourceInfos( DataGraphPipelineResourceInfoARM const * pResourceInfos_ ) & VULKAN_HPP_NOEXCEPT
    {
      pResourceInfos = pResourceInfos_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setPResourceInfos( DataGraphPipelineResourceInfoARM const * pResourceInfos_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pResourceInfos = pResourceInfos_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphPipelineCreateInfoARM &
      setResourceInfos( ArrayProxyNoTemporaries<DataGraphPipelineResourceInfoARM const> const & resourceInfos_ ) VULKAN_HPP_NOEXCEPT
    {
      resourceInfoCount = static_cast<uint32_t>( resourceInfos_.size() );
      pResourceInfos    = resourceInfos_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineCreateInfoARM *>( this );
    }

    operator VkDataGraphPipelineCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               PipelineCreateFlags2 const &,
               PipelineLayout const &,
               uint32_t const &,
               DataGraphPipelineResourceInfoARM const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, layout, resourceInfoCount, pResourceInfos );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineCreateInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( layout == rhs.layout ) &&
             ( resourceInfoCount == rhs.resourceInfoCount ) && ( pResourceInfos == rhs.pResourceInfos );
#  endif
    }

    bool operator!=( DataGraphPipelineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                            sType             = StructureType::eDataGraphPipelineCreateInfoARM;
    void const *                             pNext             = {};
    PipelineCreateFlags2                     flags             = {};
    PipelineLayout                           layout            = {};
    uint32_t                                 resourceInfoCount = {};
    DataGraphPipelineResourceInfoARM const * pResourceInfos    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineCreateInfoARM>
  {
    using Type = DataGraphPipelineCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineCreateInfoARM>
  {
    using Type = DataGraphPipelineCreateInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineDispatchInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineDispatchInfoARM.html
  struct DataGraphPipelineDispatchInfoARM
  {
    using NativeType = VkDataGraphPipelineDispatchInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineDispatchInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineDispatchInfoARM( DataGraphPipelineDispatchFlagsARM flags_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineDispatchInfoARM( DataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineDispatchInfoARM( VkDataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineDispatchInfoARM( *reinterpret_cast<DataGraphPipelineDispatchInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineDispatchInfoARM & operator=( DataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineDispatchInfoARM & operator=( VkDataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineDispatchInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM & setFlags( DataGraphPipelineDispatchFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM && setFlags( DataGraphPipelineDispatchFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineDispatchInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineDispatchInfoARM const *>( this );
    }

    operator VkDataGraphPipelineDispatchInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineDispatchInfoARM *>( this );
    }

    operator VkDataGraphPipelineDispatchInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineDispatchInfoARM const *>( this );
    }

    operator VkDataGraphPipelineDispatchInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineDispatchInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, DataGraphPipelineDispatchFlagsARM const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineDispatchInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineDispatchInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
#  endif
    }

    bool operator!=( DataGraphPipelineDispatchInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                     sType = StructureType::eDataGraphPipelineDispatchInfoARM;
    void *                            pNext = {};
    DataGraphPipelineDispatchFlagsARM flags = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineDispatchInfoARM>
  {
    using Type = DataGraphPipelineDispatchInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineDispatchInfoARM>
  {
    using Type = DataGraphPipelineDispatchInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineIdentifierCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineIdentifierCreateInfoARM.html
  struct DataGraphPipelineIdentifierCreateInfoARM
  {
    using NativeType = VkDataGraphPipelineIdentifierCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineIdentifierCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineIdentifierCreateInfoARM( uint32_t        identifierSize_ = {},
                                                                   uint8_t const * pIdentifier_    = {},
                                                                   void const *    pNext_          = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , identifierSize{ identifierSize_ }
      , pIdentifier{ pIdentifier_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineIdentifierCreateInfoARM( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineIdentifierCreateInfoARM( VkDataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineIdentifierCreateInfoARM( *reinterpret_cast<DataGraphPipelineIdentifierCreateInfoARM const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphPipelineIdentifierCreateInfoARM( ArrayProxyNoTemporaries<uint8_t const> const & identifier_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), identifierSize( static_cast<uint32_t>( identifier_.size() ) ), pIdentifier( identifier_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DataGraphPipelineIdentifierCreateInfoARM & operator=( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineIdentifierCreateInfoARM & operator=( VkDataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineIdentifierCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM & setIdentifierSize( uint32_t identifierSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      identifierSize = identifierSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM && setIdentifierSize( uint32_t identifierSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      identifierSize = identifierSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM & setPIdentifier( uint8_t const * pIdentifier_ ) & VULKAN_HPP_NOEXCEPT
    {
      pIdentifier = pIdentifier_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM && setPIdentifier( uint8_t const * pIdentifier_ ) && VULKAN_HPP_NOEXCEPT
    {
      pIdentifier = pIdentifier_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphPipelineIdentifierCreateInfoARM & setIdentifier( ArrayProxyNoTemporaries<uint8_t const> const & identifier_ ) VULKAN_HPP_NOEXCEPT
    {
      identifierSize = static_cast<uint32_t>( identifier_.size() );
      pIdentifier    = identifier_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineIdentifierCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineIdentifierCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineIdentifierCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineIdentifierCreateInfoARM *>( this );
    }

    operator VkDataGraphPipelineIdentifierCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineIdentifierCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineIdentifierCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineIdentifierCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, uint8_t const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, identifierSize, pIdentifier );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineIdentifierCreateInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && ( pIdentifier == rhs.pIdentifier );
#  endif
    }

    bool operator!=( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType   sType          = StructureType::eDataGraphPipelineIdentifierCreateInfoARM;
    void const *    pNext          = {};
    uint32_t        identifierSize = {};
    uint8_t const * pIdentifier    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineIdentifierCreateInfoARM>
  {
    using Type = DataGraphPipelineIdentifierCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineIdentifierCreateInfoARM>
  {
    using Type = DataGraphPipelineIdentifierCreateInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineInfoARM.html
  struct DataGraphPipelineInfoARM
  {
    using NativeType = VkDataGraphPipelineInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineInfoARM( Pipeline dataGraphPipeline_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , dataGraphPipeline{ dataGraphPipeline_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineInfoARM( DataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineInfoARM( VkDataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineInfoARM( *reinterpret_cast<DataGraphPipelineInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineInfoARM & operator=( DataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineInfoARM & operator=( VkDataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM & setDataGraphPipeline( Pipeline dataGraphPipeline_ ) & VULKAN_HPP_NOEXCEPT
    {
      dataGraphPipeline = dataGraphPipeline_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM && setDataGraphPipeline( Pipeline dataGraphPipeline_ ) && VULKAN_HPP_NOEXCEPT
    {
      dataGraphPipeline = dataGraphPipeline_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineInfoARM const *>( this );
    }

    operator VkDataGraphPipelineInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineInfoARM *>( this );
    }

    operator VkDataGraphPipelineInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineInfoARM const *>( this );
    }

    operator VkDataGraphPipelineInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Pipeline const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, dataGraphPipeline );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraphPipeline == rhs.dataGraphPipeline );
#  endif
    }

    bool operator!=( DataGraphPipelineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType             = StructureType::eDataGraphPipelineInfoARM;
    void const *  pNext             = {};
    Pipeline      dataGraphPipeline = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineInfoARM>
  {
    using Type = DataGraphPipelineInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineInfoARM>
  {
    using Type = DataGraphPipelineInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineNeuralStatisticsCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineNeuralStatisticsCreateInfoARM.html
  struct DataGraphPipelineNeuralStatisticsCreateInfoARM
  {
    using NativeType = VkDataGraphPipelineNeuralStatisticsCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineNeuralStatisticsCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineNeuralStatisticsCreateInfoARM( Bool32 allowNeuralStatistics_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , allowNeuralStatistics{ allowNeuralStatistics_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineNeuralStatisticsCreateInfoARM( DataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineNeuralStatisticsCreateInfoARM( VkDataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineNeuralStatisticsCreateInfoARM( *reinterpret_cast<DataGraphPipelineNeuralStatisticsCreateInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineNeuralStatisticsCreateInfoARM & operator=( DataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineNeuralStatisticsCreateInfoARM & operator=( VkDataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineNeuralStatisticsCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineNeuralStatisticsCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineNeuralStatisticsCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineNeuralStatisticsCreateInfoARM & setAllowNeuralStatistics( Bool32 allowNeuralStatistics_ ) & VULKAN_HPP_NOEXCEPT
    {
      allowNeuralStatistics = allowNeuralStatistics_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineNeuralStatisticsCreateInfoARM && setAllowNeuralStatistics( Bool32 allowNeuralStatistics_ ) && VULKAN_HPP_NOEXCEPT
    {
      allowNeuralStatistics = allowNeuralStatistics_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineNeuralStatisticsCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineNeuralStatisticsCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineNeuralStatisticsCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineNeuralStatisticsCreateInfoARM *>( this );
    }

    operator VkDataGraphPipelineNeuralStatisticsCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineNeuralStatisticsCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineNeuralStatisticsCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineNeuralStatisticsCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, allowNeuralStatistics );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineNeuralStatisticsCreateInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allowNeuralStatistics == rhs.allowNeuralStatistics );
#  endif
    }

    bool operator!=( DataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                 = StructureType::eDataGraphPipelineNeuralStatisticsCreateInfoARM;
    void const *  pNext                 = {};
    Bool32        allowNeuralStatistics = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineNeuralStatisticsCreateInfoARM>
  {
    using Type = DataGraphPipelineNeuralStatisticsCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineNeuralStatisticsCreateInfoARM>
  {
    using Type = DataGraphPipelineNeuralStatisticsCreateInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineOpticalFlowCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineOpticalFlowCreateInfoARM.html
  struct DataGraphPipelineOpticalFlowCreateInfoARM
  {
    using NativeType = VkDataGraphPipelineOpticalFlowCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineOpticalFlowCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineOpticalFlowCreateInfoARM( uint32_t                                width_            = {},
                                                 uint32_t                                height_           = {},
                                                 Format                                  imageFormat_      = Format::eUndefined,
                                                 Format                                  flowVectorFormat_ = Format::eUndefined,
                                                 Format                                  costFormat_       = Format::eUndefined,
                                                 DataGraphOpticalFlowGridSizeFlagsARM    outputGridSize_   = {},
                                                 DataGraphOpticalFlowGridSizeFlagsARM    hintGridSize_     = {},
                                                 DataGraphOpticalFlowPerformanceLevelARM performanceLevel_ = DataGraphOpticalFlowPerformanceLevelARM::eUnknown,
                                                 DataGraphOpticalFlowCreateFlagsARM      flags_            = {},
                                                 void *                                  pNext_            = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , width{ width_ }
      , height{ height_ }
      , imageFormat{ imageFormat_ }
      , flowVectorFormat{ flowVectorFormat_ }
      , costFormat{ costFormat_ }
      , outputGridSize{ outputGridSize_ }
      , hintGridSize{ hintGridSize_ }
      , performanceLevel{ performanceLevel_ }
      , flags{ flags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineOpticalFlowCreateInfoARM( DataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineOpticalFlowCreateInfoARM( VkDataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineOpticalFlowCreateInfoARM( *reinterpret_cast<DataGraphPipelineOpticalFlowCreateInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineOpticalFlowCreateInfoARM & operator=( DataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineOpticalFlowCreateInfoARM & operator=( VkDataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineOpticalFlowCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT
    {
      width = width_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT
    {
      width = width_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT
    {
      height = height_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT
    {
      height = height_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setImageFormat( Format imageFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageFormat = imageFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setImageFormat( Format imageFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageFormat = imageFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setFlowVectorFormat( Format flowVectorFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      flowVectorFormat = flowVectorFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setFlowVectorFormat( Format flowVectorFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      flowVectorFormat = flowVectorFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setCostFormat( Format costFormat_ ) & VULKAN_HPP_NOEXCEPT
    {
      costFormat = costFormat_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setCostFormat( Format costFormat_ ) && VULKAN_HPP_NOEXCEPT
    {
      costFormat = costFormat_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setOutputGridSize( DataGraphOpticalFlowGridSizeFlagsARM outputGridSize_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      outputGridSize = outputGridSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setOutputGridSize( DataGraphOpticalFlowGridSizeFlagsARM outputGridSize_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      outputGridSize = outputGridSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setHintGridSize( DataGraphOpticalFlowGridSizeFlagsARM hintGridSize_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      hintGridSize = hintGridSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setHintGridSize( DataGraphOpticalFlowGridSizeFlagsARM hintGridSize_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      hintGridSize = hintGridSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setPerformanceLevel( DataGraphOpticalFlowPerformanceLevelARM performanceLevel_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      performanceLevel = performanceLevel_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setPerformanceLevel( DataGraphOpticalFlowPerformanceLevelARM performanceLevel_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      performanceLevel = performanceLevel_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setFlags( DataGraphOpticalFlowCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setFlags( DataGraphOpticalFlowCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineOpticalFlowCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineOpticalFlowCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineOpticalFlowCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineOpticalFlowCreateInfoARM *>( this );
    }

    operator VkDataGraphPipelineOpticalFlowCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineOpticalFlowCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineOpticalFlowCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineOpticalFlowCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               uint32_t const &,
               uint32_t const &,
               Format const &,
               Format const &,
               Format const &,
               DataGraphOpticalFlowGridSizeFlagsARM const &,
               DataGraphOpticalFlowGridSizeFlagsARM const &,
               DataGraphOpticalFlowPerformanceLevelARM const &,
               DataGraphOpticalFlowCreateFlagsARM const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, width, height, imageFormat, flowVectorFormat, costFormat, outputGridSize, hintGridSize, performanceLevel, flags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineOpticalFlowCreateInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( width == rhs.width ) && ( height == rhs.height ) && ( imageFormat == rhs.imageFormat ) &&
             ( flowVectorFormat == rhs.flowVectorFormat ) && ( costFormat == rhs.costFormat ) && ( outputGridSize == rhs.outputGridSize ) &&
             ( hintGridSize == rhs.hintGridSize ) && ( performanceLevel == rhs.performanceLevel ) && ( flags == rhs.flags );
#  endif
    }

    bool operator!=( DataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                           sType            = StructureType::eDataGraphPipelineOpticalFlowCreateInfoARM;
    void *                                  pNext            = {};
    uint32_t                                width            = {};
    uint32_t                                height           = {};
    Format                                  imageFormat      = Format::eUndefined;
    Format                                  flowVectorFormat = Format::eUndefined;
    Format                                  costFormat       = Format::eUndefined;
    DataGraphOpticalFlowGridSizeFlagsARM    outputGridSize   = {};
    DataGraphOpticalFlowGridSizeFlagsARM    hintGridSize     = {};
    DataGraphOpticalFlowPerformanceLevelARM performanceLevel = DataGraphOpticalFlowPerformanceLevelARM::eUnknown;
    DataGraphOpticalFlowCreateFlagsARM      flags            = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineOpticalFlowCreateInfoARM>
  {
    using Type = DataGraphPipelineOpticalFlowCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineOpticalFlowCreateInfoARM>
  {
    using Type = DataGraphPipelineOpticalFlowCreateInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineOpticalFlowDispatchInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineOpticalFlowDispatchInfoARM.html
  struct DataGraphPipelineOpticalFlowDispatchInfoARM
  {
    using NativeType = VkDataGraphPipelineOpticalFlowDispatchInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineOpticalFlowDispatchInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineOpticalFlowDispatchInfoARM( DataGraphOpticalFlowExecuteFlagsARM flags_              = {},
                                                                      uint32_t                            meanFlowL1NormHint_ = {},
                                                                      void *                              pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , meanFlowL1NormHint{ meanFlowL1NormHint_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineOpticalFlowDispatchInfoARM( DataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineOpticalFlowDispatchInfoARM( VkDataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineOpticalFlowDispatchInfoARM( *reinterpret_cast<DataGraphPipelineOpticalFlowDispatchInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineOpticalFlowDispatchInfoARM & operator=( DataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineOpticalFlowDispatchInfoARM & operator=( VkDataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineOpticalFlowDispatchInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM & setFlags( DataGraphOpticalFlowExecuteFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM && setFlags( DataGraphOpticalFlowExecuteFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM & setMeanFlowL1NormHint( uint32_t meanFlowL1NormHint_ ) & VULKAN_HPP_NOEXCEPT
    {
      meanFlowL1NormHint = meanFlowL1NormHint_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM && setMeanFlowL1NormHint( uint32_t meanFlowL1NormHint_ ) && VULKAN_HPP_NOEXCEPT
    {
      meanFlowL1NormHint = meanFlowL1NormHint_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineOpticalFlowDispatchInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineOpticalFlowDispatchInfoARM const *>( this );
    }

    operator VkDataGraphPipelineOpticalFlowDispatchInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineOpticalFlowDispatchInfoARM *>( this );
    }

    operator VkDataGraphPipelineOpticalFlowDispatchInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineOpticalFlowDispatchInfoARM const *>( this );
    }

    operator VkDataGraphPipelineOpticalFlowDispatchInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineOpticalFlowDispatchInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, DataGraphOpticalFlowExecuteFlagsARM const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, meanFlowL1NormHint );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineOpticalFlowDispatchInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( meanFlowL1NormHint == rhs.meanFlowL1NormHint );
#  endif
    }

    bool operator!=( DataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                       sType              = StructureType::eDataGraphPipelineOpticalFlowDispatchInfoARM;
    void *                              pNext              = {};
    DataGraphOpticalFlowExecuteFlagsARM flags              = {};
    uint32_t                            meanFlowL1NormHint = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineOpticalFlowDispatchInfoARM>
  {
    using Type = DataGraphPipelineOpticalFlowDispatchInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineOpticalFlowDispatchInfoARM>
  {
    using Type = DataGraphPipelineOpticalFlowDispatchInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelinePropertyQueryResultARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelinePropertyQueryResultARM.html
  struct DataGraphPipelinePropertyQueryResultARM
  {
    using NativeType = VkDataGraphPipelinePropertyQueryResultARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelinePropertyQueryResultARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelinePropertyQueryResultARM( DataGraphPipelinePropertyARM property_ = DataGraphPipelinePropertyARM::eCreationLog,
                                                                  Bool32                       isText_   = {},
                                                                  size_t                       dataSize_ = {},
                                                                  void *                       pData_    = {},
                                                                  void *                       pNext_    = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , property{ property_ }
      , isText{ isText_ }
      , dataSize{ dataSize_ }
      , pData{ pData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelinePropertyQueryResultARM( DataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelinePropertyQueryResultARM( VkDataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelinePropertyQueryResultARM( *reinterpret_cast<DataGraphPipelinePropertyQueryResultARM const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    DataGraphPipelinePropertyQueryResultARM( DataGraphPipelinePropertyARM       property_,
                                             Bool32                             isText_,
                                             ArrayProxyNoTemporaries<T> const & data_,
                                             void *                             pNext_ = nullptr )
      : pNext( pNext_ ), property( property_ ), isText( isText_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DataGraphPipelinePropertyQueryResultARM & operator=( DataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelinePropertyQueryResultARM & operator=( VkDataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelinePropertyQueryResultARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setProperty( DataGraphPipelinePropertyARM property_ ) & VULKAN_HPP_NOEXCEPT
    {
      property = property_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setProperty( DataGraphPipelinePropertyARM property_ ) && VULKAN_HPP_NOEXCEPT
    {
      property = property_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setIsText( Bool32 isText_ ) & VULKAN_HPP_NOEXCEPT
    {
      isText = isText_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setIsText( Bool32 isText_ ) && VULKAN_HPP_NOEXCEPT
    {
      isText = isText_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      dataSize = dataSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setPData( void * pData_ ) & VULKAN_HPP_NOEXCEPT
    {
      pData = pData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setPData( void * pData_ ) && VULKAN_HPP_NOEXCEPT
    {
      pData = pData_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    DataGraphPipelinePropertyQueryResultARM & setData( ArrayProxyNoTemporaries<T> const & data_ ) VULKAN_HPP_NOEXCEPT
    {
      dataSize = data_.size() * sizeof( T );
      pData    = data_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelinePropertyQueryResultARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelinePropertyQueryResultARM const *>( this );
    }

    operator VkDataGraphPipelinePropertyQueryResultARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelinePropertyQueryResultARM *>( this );
    }

    operator VkDataGraphPipelinePropertyQueryResultARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelinePropertyQueryResultARM const *>( this );
    }

    operator VkDataGraphPipelinePropertyQueryResultARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelinePropertyQueryResultARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, DataGraphPipelinePropertyARM const &, Bool32 const &, size_t const &, void * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, property, isText, dataSize, pData );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelinePropertyQueryResultARM const & ) const = default;
#else
    bool operator==( DataGraphPipelinePropertyQueryResultARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( property == rhs.property ) && ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) &&
             ( pData == rhs.pData );
#  endif
    }

    bool operator!=( DataGraphPipelinePropertyQueryResultARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                sType    = StructureType::eDataGraphPipelinePropertyQueryResultARM;
    void *                       pNext    = {};
    DataGraphPipelinePropertyARM property = DataGraphPipelinePropertyARM::eCreationLog;
    Bool32                       isText   = {};
    size_t                       dataSize = {};
    void *                       pData    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelinePropertyQueryResultARM>
  {
    using Type = DataGraphPipelinePropertyQueryResultARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelinePropertyQueryResultARM>
  {
    using Type = DataGraphPipelinePropertyQueryResultARM;
  };

  // wrapper struct for struct VkDataGraphPipelineResourceInfoImageLayoutARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineResourceInfoImageLayoutARM.html
  struct DataGraphPipelineResourceInfoImageLayoutARM
  {
    using NativeType = VkDataGraphPipelineResourceInfoImageLayoutARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineResourceInfoImageLayoutARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoImageLayoutARM( ImageLayout  layout_ = ImageLayout::eUndefined,
                                                                      void const * pNext_  = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , layout{ layout_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoImageLayoutARM( DataGraphPipelineResourceInfoImageLayoutARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineResourceInfoImageLayoutARM( VkDataGraphPipelineResourceInfoImageLayoutARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineResourceInfoImageLayoutARM( *reinterpret_cast<DataGraphPipelineResourceInfoImageLayoutARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineResourceInfoImageLayoutARM & operator=( DataGraphPipelineResourceInfoImageLayoutARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineResourceInfoImageLayoutARM & operator=( VkDataGraphPipelineResourceInfoImageLayoutARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineResourceInfoImageLayoutARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoImageLayoutARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoImageLayoutARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoImageLayoutARM & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoImageLayoutARM && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT
    {
      layout = layout_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineResourceInfoImageLayoutARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineResourceInfoImageLayoutARM const *>( this );
    }

    operator VkDataGraphPipelineResourceInfoImageLayoutARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineResourceInfoImageLayoutARM *>( this );
    }

    operator VkDataGraphPipelineResourceInfoImageLayoutARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineResourceInfoImageLayoutARM const *>( this );
    }

    operator VkDataGraphPipelineResourceInfoImageLayoutARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineResourceInfoImageLayoutARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, ImageLayout const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, layout );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineResourceInfoImageLayoutARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineResourceInfoImageLayoutARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( layout == rhs.layout );
#  endif
    }

    bool operator!=( DataGraphPipelineResourceInfoImageLayoutARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType  = StructureType::eDataGraphPipelineResourceInfoImageLayoutARM;
    void const *  pNext  = {};
    ImageLayout   layout = ImageLayout::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineResourceInfoImageLayoutARM>
  {
    using Type = DataGraphPipelineResourceInfoImageLayoutARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineResourceInfoImageLayoutARM>
  {
    using Type = DataGraphPipelineResourceInfoImageLayoutARM;
  };

  // wrapper struct for struct VkDataGraphPipelineSessionBindPointRequirementARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointRequirementARM.html
  struct DataGraphPipelineSessionBindPointRequirementARM
  {
    using NativeType = VkDataGraphPipelineSessionBindPointRequirementARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineSessionBindPointRequirementARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionBindPointRequirementARM(
      DataGraphPipelineSessionBindPointARM     bindPoint_     = DataGraphPipelineSessionBindPointARM::eTransient,
      DataGraphPipelineSessionBindPointTypeARM bindPointType_ = DataGraphPipelineSessionBindPointTypeARM::eMemory,
      uint32_t                                 numObjects_    = {},
      void *                                   pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , bindPoint{ bindPoint_ }
      , bindPointType{ bindPointType_ }
      , numObjects{ numObjects_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineSessionBindPointRequirementARM( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineSessionBindPointRequirementARM( VkDataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineSessionBindPointRequirementARM( *reinterpret_cast<DataGraphPipelineSessionBindPointRequirementARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineSessionBindPointRequirementARM & operator=( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineSessionBindPointRequirementARM & operator=( VkDataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineSessionBindPointRequirementARM const *>( &rhs );
      return *this;
    }

    operator VkDataGraphPipelineSessionBindPointRequirementARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementARM const *>( this );
    }

    operator VkDataGraphPipelineSessionBindPointRequirementARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementARM *>( this );
    }

    operator VkDataGraphPipelineSessionBindPointRequirementARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementARM const *>( this );
    }

    operator VkDataGraphPipelineSessionBindPointRequirementARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               DataGraphPipelineSessionBindPointARM const &,
               DataGraphPipelineSessionBindPointTypeARM const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, bindPoint, bindPointType, numObjects );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineSessionBindPointRequirementARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindPoint == rhs.bindPoint ) && ( bindPointType == rhs.bindPointType ) &&
             ( numObjects == rhs.numObjects );
#  endif
    }

    bool operator!=( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                            sType         = StructureType::eDataGraphPipelineSessionBindPointRequirementARM;
    void *                                   pNext         = {};
    DataGraphPipelineSessionBindPointARM     bindPoint     = DataGraphPipelineSessionBindPointARM::eTransient;
    DataGraphPipelineSessionBindPointTypeARM bindPointType = DataGraphPipelineSessionBindPointTypeARM::eMemory;
    uint32_t                                 numObjects    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineSessionBindPointRequirementARM>
  {
    using Type = DataGraphPipelineSessionBindPointRequirementARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineSessionBindPointRequirementARM>
  {
    using Type = DataGraphPipelineSessionBindPointRequirementARM;
  };

  // wrapper struct for struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointRequirementsInfoARM.html
  struct DataGraphPipelineSessionBindPointRequirementsInfoARM
  {
    using NativeType = VkDataGraphPipelineSessionBindPointRequirementsInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionBindPointRequirementsInfoARM( DataGraphPipelineSessionARM session_ = {},
                                                                               void const *                pNext_   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , session{ session_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineSessionBindPointRequirementsInfoARM( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineSessionBindPointRequirementsInfoARM( VkDataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineSessionBindPointRequirementsInfoARM( *reinterpret_cast<DataGraphPipelineSessionBindPointRequirementsInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineSessionBindPointRequirementsInfoARM &
      operator=( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineSessionBindPointRequirementsInfoARM & operator=( VkDataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineSessionBindPointRequirementsInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM & setSession( DataGraphPipelineSessionARM session_ ) & VULKAN_HPP_NOEXCEPT
    {
      session = session_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM && setSession( DataGraphPipelineSessionARM session_ ) && VULKAN_HPP_NOEXCEPT
    {
      session = session_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementsInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementsInfoARM *>( this );
    }

    operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementsInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionBindPointRequirementsInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DataGraphPipelineSessionARM const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, session );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineSessionBindPointRequirementsInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( session == rhs.session );
#  endif
    }

    bool operator!=( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType               sType   = StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM;
    void const *                pNext   = {};
    DataGraphPipelineSessionARM session = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineSessionBindPointRequirementsInfoARM>
  {
    using Type = DataGraphPipelineSessionBindPointRequirementsInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM>
  {
    using Type = DataGraphPipelineSessionBindPointRequirementsInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineSessionCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateInfoARM.html
  struct DataGraphPipelineSessionCreateInfoARM
  {
    using NativeType = VkDataGraphPipelineSessionCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineSessionCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionCreateInfoARM( DataGraphPipelineSessionCreateFlagsARM flags_             = {},
                                                                Pipeline                               dataGraphPipeline_ = {},
                                                                void const *                           pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , dataGraphPipeline{ dataGraphPipeline_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionCreateInfoARM( DataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineSessionCreateInfoARM( VkDataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineSessionCreateInfoARM( *reinterpret_cast<DataGraphPipelineSessionCreateInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineSessionCreateInfoARM & operator=( DataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineSessionCreateInfoARM & operator=( VkDataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineSessionCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM & setFlags( DataGraphPipelineSessionCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM && setFlags( DataGraphPipelineSessionCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM & setDataGraphPipeline( Pipeline dataGraphPipeline_ ) & VULKAN_HPP_NOEXCEPT
    {
      dataGraphPipeline = dataGraphPipeline_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM && setDataGraphPipeline( Pipeline dataGraphPipeline_ ) && VULKAN_HPP_NOEXCEPT
    {
      dataGraphPipeline = dataGraphPipeline_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineSessionCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSessionCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionCreateInfoARM *>( this );
    }

    operator VkDataGraphPipelineSessionCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSessionCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DataGraphPipelineSessionCreateFlagsARM const &, Pipeline const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, dataGraphPipeline );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineSessionCreateInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineSessionCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dataGraphPipeline == rhs.dataGraphPipeline );
#  endif
    }

    bool operator!=( DataGraphPipelineSessionCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                          sType             = StructureType::eDataGraphPipelineSessionCreateInfoARM;
    void const *                           pNext             = {};
    DataGraphPipelineSessionCreateFlagsARM flags             = {};
    Pipeline                               dataGraphPipeline = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineSessionCreateInfoARM>
  {
    using Type = DataGraphPipelineSessionCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineSessionCreateInfoARM>
  {
    using Type = DataGraphPipelineSessionCreateInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionMemoryRequirementsInfoARM.html
  struct DataGraphPipelineSessionMemoryRequirementsInfoARM
  {
    using NativeType = VkDataGraphPipelineSessionMemoryRequirementsInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineSessionMemoryRequirementsInfoARM( DataGraphPipelineSessionARM          session_     = {},
                                                         DataGraphPipelineSessionBindPointARM bindPoint_   = DataGraphPipelineSessionBindPointARM::eTransient,
                                                         uint32_t                             objectIndex_ = {},
                                                         void const *                         pNext_       = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , session{ session_ }
      , bindPoint{ bindPoint_ }
      , objectIndex{ objectIndex_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineSessionMemoryRequirementsInfoARM( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineSessionMemoryRequirementsInfoARM( VkDataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineSessionMemoryRequirementsInfoARM( *reinterpret_cast<DataGraphPipelineSessionMemoryRequirementsInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineSessionMemoryRequirementsInfoARM &
      operator=( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineSessionMemoryRequirementsInfoARM & operator=( VkDataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineSessionMemoryRequirementsInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setSession( DataGraphPipelineSessionARM session_ ) & VULKAN_HPP_NOEXCEPT
    {
      session = session_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setSession( DataGraphPipelineSessionARM session_ ) && VULKAN_HPP_NOEXCEPT
    {
      session = session_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      bindPoint = bindPoint_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      bindPoint = bindPoint_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setObjectIndex( uint32_t objectIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      objectIndex = objectIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setObjectIndex( uint32_t objectIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      objectIndex = objectIndex_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionMemoryRequirementsInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionMemoryRequirementsInfoARM *>( this );
    }

    operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionMemoryRequirementsInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionMemoryRequirementsInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DataGraphPipelineSessionARM const &, DataGraphPipelineSessionBindPointARM const &, uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, session, bindPoint, objectIndex );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineSessionMemoryRequirementsInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( session == rhs.session ) && ( bindPoint == rhs.bindPoint ) &&
             ( objectIndex == rhs.objectIndex );
#  endif
    }

    bool operator!=( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                        sType       = StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM;
    void const *                         pNext       = {};
    DataGraphPipelineSessionARM          session     = {};
    DataGraphPipelineSessionBindPointARM bindPoint   = DataGraphPipelineSessionBindPointARM::eTransient;
    uint32_t                             objectIndex = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineSessionMemoryRequirementsInfoARM>
  {
    using Type = DataGraphPipelineSessionMemoryRequirementsInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM>
  {
    using Type = DataGraphPipelineSessionMemoryRequirementsInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM.html
  struct DataGraphPipelineSessionNeuralStatisticsCreateInfoARM
  {
    using NativeType = VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineSessionNeuralStatisticsCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineSessionNeuralStatisticsCreateInfoARM( NeuralAcceleratorStatisticsModeARM mode_  = NeuralAcceleratorStatisticsModeARM::eDisabled,
                                                             void const *                       pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , mode{ mode_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineSessionNeuralStatisticsCreateInfoARM( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineSessionNeuralStatisticsCreateInfoARM( VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineSessionNeuralStatisticsCreateInfoARM( *reinterpret_cast<DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineSessionNeuralStatisticsCreateInfoARM &
      operator=( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineSessionNeuralStatisticsCreateInfoARM & operator=( VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionNeuralStatisticsCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionNeuralStatisticsCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionNeuralStatisticsCreateInfoARM & setMode( NeuralAcceleratorStatisticsModeARM mode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionNeuralStatisticsCreateInfoARM && setMode( NeuralAcceleratorStatisticsModeARM mode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mode = mode_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM *>( this );
    }

    operator VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, NeuralAcceleratorStatisticsModeARM const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, mode );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode );
#  endif
    }

    bool operator!=( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                      sType = StructureType::eDataGraphPipelineSessionNeuralStatisticsCreateInfoARM;
    void const *                       pNext = {};
    NeuralAcceleratorStatisticsModeARM mode  = NeuralAcceleratorStatisticsModeARM::eDisabled;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM>
  {
    using Type = DataGraphPipelineSessionNeuralStatisticsCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineSessionNeuralStatisticsCreateInfoARM>
  {
    using Type = DataGraphPipelineSessionNeuralStatisticsCreateInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineShaderModuleCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineShaderModuleCreateInfoARM.html
  struct DataGraphPipelineShaderModuleCreateInfoARM
  {
    using NativeType = VkDataGraphPipelineShaderModuleCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineShaderModuleCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineShaderModuleCreateInfoARM( ShaderModule                         module_              = {},
                                                                     char const *                         pName_               = {},
                                                                     SpecializationInfo const *           pSpecializationInfo_ = {},
                                                                     uint32_t                             constantCount_       = {},
                                                                     DataGraphPipelineConstantARM const * pConstants_          = {},
                                                                     void const *                         pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , module{ module_ }
      , pName{ pName_ }
      , pSpecializationInfo{ pSpecializationInfo_ }
      , constantCount{ constantCount_ }
      , pConstants{ pConstants_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineShaderModuleCreateInfoARM( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineShaderModuleCreateInfoARM( VkDataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineShaderModuleCreateInfoARM( *reinterpret_cast<DataGraphPipelineShaderModuleCreateInfoARM const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphPipelineShaderModuleCreateInfoARM( ShaderModule                                                        module_,
                                                char const *                                                        pName_,
                                                SpecializationInfo const *                                          pSpecializationInfo_,
                                                ArrayProxyNoTemporaries<DataGraphPipelineConstantARM const> const & constants_,
                                                void const *                                                        pNext_ = nullptr )
      : pNext( pNext_ )
      , module( module_ )
      , pName( pName_ )
      , pSpecializationInfo( pSpecializationInfo_ )
      , constantCount( static_cast<uint32_t>( constants_.size() ) )
      , pConstants( constants_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DataGraphPipelineShaderModuleCreateInfoARM & operator=( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineShaderModuleCreateInfoARM & operator=( VkDataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineShaderModuleCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setModule( ShaderModule module_ ) & VULKAN_HPP_NOEXCEPT
    {
      module = module_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setModule( ShaderModule module_ ) && VULKAN_HPP_NOEXCEPT
    {
      module = module_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPName( char const * pName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pName = pName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPName( char const * pName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pName = pName_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPSpecializationInfo( SpecializationInfo const * pSpecializationInfo_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pSpecializationInfo = pSpecializationInfo_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPSpecializationInfo( SpecializationInfo const * pSpecializationInfo_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pSpecializationInfo = pSpecializationInfo_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setConstantCount( uint32_t constantCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      constantCount = constantCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setConstantCount( uint32_t constantCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      constantCount = constantCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPConstants( DataGraphPipelineConstantARM const * pConstants_ ) & VULKAN_HPP_NOEXCEPT
    {
      pConstants = pConstants_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPConstants( DataGraphPipelineConstantARM const * pConstants_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pConstants = pConstants_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphPipelineShaderModuleCreateInfoARM &
      setConstants( ArrayProxyNoTemporaries<DataGraphPipelineConstantARM const> const & constants_ ) VULKAN_HPP_NOEXCEPT
    {
      constantCount = static_cast<uint32_t>( constants_.size() );
      pConstants    = constants_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineShaderModuleCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineShaderModuleCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineShaderModuleCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineShaderModuleCreateInfoARM *>( this );
    }

    operator VkDataGraphPipelineShaderModuleCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineShaderModuleCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineShaderModuleCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineShaderModuleCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               ShaderModule const &,
               char const * const &,
               SpecializationInfo const * const &,
               uint32_t const &,
               DataGraphPipelineConstantARM const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, module, pName, pSpecializationInfo, constantCount, pConstants );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( auto cmp = module <=> rhs.module; cmp != 0 )
        return cmp;
      if ( pName != rhs.pName )
        if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
      if ( auto cmp = pSpecializationInfo <=> rhs.pSpecializationInfo; cmp != 0 )
        return cmp;
      if ( auto cmp = constantCount <=> rhs.constantCount; cmp != 0 )
        return cmp;
      if ( auto cmp = pConstants <=> rhs.pConstants; cmp != 0 )
        return cmp;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) &&
             ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( pSpecializationInfo == rhs.pSpecializationInfo ) &&
             ( constantCount == rhs.constantCount ) && ( pConstants == rhs.pConstants );
    }

    bool operator!=( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType                        sType               = StructureType::eDataGraphPipelineShaderModuleCreateInfoARM;
    void const *                         pNext               = {};
    ShaderModule                         module              = {};
    char const *                         pName               = {};
    SpecializationInfo const *           pSpecializationInfo = {};
    uint32_t                             constantCount       = {};
    DataGraphPipelineConstantARM const * pConstants          = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineShaderModuleCreateInfoARM>
  {
    using Type = DataGraphPipelineShaderModuleCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineShaderModuleCreateInfoARM>
  {
    using Type = DataGraphPipelineShaderModuleCreateInfoARM;
  };

  // wrapper struct for struct VkDataGraphPipelineSingleNodeConnectionARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSingleNodeConnectionARM.html
  struct DataGraphPipelineSingleNodeConnectionARM
  {
    using NativeType = VkDataGraphPipelineSingleNodeConnectionARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineSingleNodeConnectionARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      DataGraphPipelineSingleNodeConnectionARM( uint32_t                               set_        = {},
                                                uint32_t                               binding_    = {},
                                                DataGraphPipelineNodeConnectionTypeARM connection_ = DataGraphPipelineNodeConnectionTypeARM::eOpticalFlowInput,
                                                void *                                 pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , set{ set_ }
      , binding{ binding_ }
      , connection{ connection_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineSingleNodeConnectionARM( DataGraphPipelineSingleNodeConnectionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineSingleNodeConnectionARM( VkDataGraphPipelineSingleNodeConnectionARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineSingleNodeConnectionARM( *reinterpret_cast<DataGraphPipelineSingleNodeConnectionARM const *>( &rhs ) )
    {
    }

    DataGraphPipelineSingleNodeConnectionARM & operator=( DataGraphPipelineSingleNodeConnectionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineSingleNodeConnectionARM & operator=( VkDataGraphPipelineSingleNodeConnectionARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineSingleNodeConnectionARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT
    {
      set = set_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT
    {
      set = set_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT
    {
      binding = binding_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT
    {
      binding = binding_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM & setConnection( DataGraphPipelineNodeConnectionTypeARM connection_ ) & VULKAN_HPP_NOEXCEPT
    {
      connection = connection_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM && setConnection( DataGraphPipelineNodeConnectionTypeARM connection_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      connection = connection_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineSingleNodeConnectionARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSingleNodeConnectionARM const *>( this );
    }

    operator VkDataGraphPipelineSingleNodeConnectionARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSingleNodeConnectionARM *>( this );
    }

    operator VkDataGraphPipelineSingleNodeConnectionARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSingleNodeConnectionARM const *>( this );
    }

    operator VkDataGraphPipelineSingleNodeConnectionARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSingleNodeConnectionARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, uint32_t const &, uint32_t const &, DataGraphPipelineNodeConnectionTypeARM const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, set, binding, connection );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineSingleNodeConnectionARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineSingleNodeConnectionARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( set == rhs.set ) && ( binding == rhs.binding ) && ( connection == rhs.connection );
#  endif
    }

    bool operator!=( DataGraphPipelineSingleNodeConnectionARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                          sType      = StructureType::eDataGraphPipelineSingleNodeConnectionARM;
    void *                                 pNext      = {};
    uint32_t                               set        = {};
    uint32_t                               binding    = {};
    DataGraphPipelineNodeConnectionTypeARM connection = DataGraphPipelineNodeConnectionTypeARM::eOpticalFlowInput;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineSingleNodeConnectionARM>
  {
    using Type = DataGraphPipelineSingleNodeConnectionARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineSingleNodeConnectionARM>
  {
    using Type = DataGraphPipelineSingleNodeConnectionARM;
  };

  // wrapper struct for struct VkDataGraphPipelineSingleNodeCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSingleNodeCreateInfoARM.html
  struct DataGraphPipelineSingleNodeCreateInfoARM
  {
    using NativeType = VkDataGraphPipelineSingleNodeCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineSingleNodeCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphPipelineSingleNodeCreateInfoARM( DataGraphPipelineNodeTypeARM nodeType_        = DataGraphPipelineNodeTypeARM::eOpticalFlow,
                                                                   uint32_t                     connectionCount_ = {},
                                                                   DataGraphPipelineSingleNodeConnectionARM const * pConnections_ = {},
                                                                   void *                                           pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , nodeType{ nodeType_ }
      , connectionCount{ connectionCount_ }
      , pConnections{ pConnections_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphPipelineSingleNodeCreateInfoARM( DataGraphPipelineSingleNodeCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphPipelineSingleNodeCreateInfoARM( VkDataGraphPipelineSingleNodeCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphPipelineSingleNodeCreateInfoARM( *reinterpret_cast<DataGraphPipelineSingleNodeCreateInfoARM const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphPipelineSingleNodeCreateInfoARM( DataGraphPipelineNodeTypeARM                                                    nodeType_,
                                              ArrayProxyNoTemporaries<DataGraphPipelineSingleNodeConnectionARM const> const & connections_,
                                              void *                                                                          pNext_ = nullptr )
      : pNext( pNext_ ), nodeType( nodeType_ ), connectionCount( static_cast<uint32_t>( connections_.size() ) ), pConnections( connections_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DataGraphPipelineSingleNodeCreateInfoARM & operator=( DataGraphPipelineSingleNodeCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphPipelineSingleNodeCreateInfoARM & operator=( VkDataGraphPipelineSingleNodeCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphPipelineSingleNodeCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM & setNodeType( DataGraphPipelineNodeTypeARM nodeType_ ) & VULKAN_HPP_NOEXCEPT
    {
      nodeType = nodeType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM && setNodeType( DataGraphPipelineNodeTypeARM nodeType_ ) && VULKAN_HPP_NOEXCEPT
    {
      nodeType = nodeType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM & setConnectionCount( uint32_t connectionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      connectionCount = connectionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM && setConnectionCount( uint32_t connectionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      connectionCount = connectionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM & setPConnections( DataGraphPipelineSingleNodeConnectionARM const * pConnections_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pConnections = pConnections_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM && setPConnections( DataGraphPipelineSingleNodeConnectionARM const * pConnections_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pConnections = pConnections_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphPipelineSingleNodeCreateInfoARM &
      setConnections( ArrayProxyNoTemporaries<DataGraphPipelineSingleNodeConnectionARM const> const & connections_ ) VULKAN_HPP_NOEXCEPT
    {
      connectionCount = static_cast<uint32_t>( connections_.size() );
      pConnections    = connections_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphPipelineSingleNodeCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSingleNodeCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSingleNodeCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphPipelineSingleNodeCreateInfoARM *>( this );
    }

    operator VkDataGraphPipelineSingleNodeCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSingleNodeCreateInfoARM const *>( this );
    }

    operator VkDataGraphPipelineSingleNodeCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphPipelineSingleNodeCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               DataGraphPipelineNodeTypeARM const &,
               uint32_t const &,
               DataGraphPipelineSingleNodeConnectionARM const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, nodeType, connectionCount, pConnections );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphPipelineSingleNodeCreateInfoARM const & ) const = default;
#else
    bool operator==( DataGraphPipelineSingleNodeCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( nodeType == rhs.nodeType ) && ( connectionCount == rhs.connectionCount ) &&
             ( pConnections == rhs.pConnections );
#  endif
    }

    bool operator!=( DataGraphPipelineSingleNodeCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                                    sType           = StructureType::eDataGraphPipelineSingleNodeCreateInfoARM;
    void *                                           pNext           = {};
    DataGraphPipelineNodeTypeARM                     nodeType        = DataGraphPipelineNodeTypeARM::eOpticalFlow;
    uint32_t                                         connectionCount = {};
    DataGraphPipelineSingleNodeConnectionARM const * pConnections    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphPipelineSingleNodeCreateInfoARM>
  {
    using Type = DataGraphPipelineSingleNodeCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphPipelineSingleNodeCreateInfoARM>
  {
    using Type = DataGraphPipelineSingleNodeCreateInfoARM;
  };

  // wrapper struct for struct VkPhysicalDeviceDataGraphProcessingEngineARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineARM.html
  struct PhysicalDeviceDataGraphProcessingEngineARM
  {
    using NativeType = VkPhysicalDeviceDataGraphProcessingEngineARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphProcessingEngineARM(
      PhysicalDeviceDataGraphProcessingEngineTypeARM type_      = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault,
      Bool32                                         isForeign_ = {} ) VULKAN_HPP_NOEXCEPT
      : type{ type_ }
      , isForeign{ isForeign_ }
    {
    }

    VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphProcessingEngineARM( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    PhysicalDeviceDataGraphProcessingEngineARM( VkPhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : PhysicalDeviceDataGraphProcessingEngineARM( *reinterpret_cast<PhysicalDeviceDataGraphProcessingEngineARM const *>( &rhs ) )
    {
    }

    PhysicalDeviceDataGraphProcessingEngineARM & operator=( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    PhysicalDeviceDataGraphProcessingEngineARM & operator=( VkPhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<PhysicalDeviceDataGraphProcessingEngineARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM & setType( PhysicalDeviceDataGraphProcessingEngineTypeARM type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM && setType( PhysicalDeviceDataGraphProcessingEngineTypeARM type_ ) && VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM & setIsForeign( Bool32 isForeign_ ) & VULKAN_HPP_NOEXCEPT
    {
      isForeign = isForeign_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM && setIsForeign( Bool32 isForeign_ ) && VULKAN_HPP_NOEXCEPT
    {
      isForeign = isForeign_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkPhysicalDeviceDataGraphProcessingEngineARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkPhysicalDeviceDataGraphProcessingEngineARM const *>( this );
    }

    operator VkPhysicalDeviceDataGraphProcessingEngineARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkPhysicalDeviceDataGraphProcessingEngineARM *>( this );
    }

    operator VkPhysicalDeviceDataGraphProcessingEngineARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkPhysicalDeviceDataGraphProcessingEngineARM const *>( this );
    }

    operator VkPhysicalDeviceDataGraphProcessingEngineARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkPhysicalDeviceDataGraphProcessingEngineARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<PhysicalDeviceDataGraphProcessingEngineTypeARM const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( type, isForeign );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( PhysicalDeviceDataGraphProcessingEngineARM const & ) const = default;
#else
    bool operator==( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( type == rhs.type ) && ( isForeign == rhs.isForeign );
#  endif
    }

    bool operator!=( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    PhysicalDeviceDataGraphProcessingEngineTypeARM type      = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault;
    Bool32                                         isForeign = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkPhysicalDeviceDataGraphProcessingEngineARM>
  {
    using Type = PhysicalDeviceDataGraphProcessingEngineARM;
  };
#endif

  // wrapper struct for struct VkDataGraphProcessingEngineCreateInfoARM, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphProcessingEngineCreateInfoARM.html
  struct DataGraphProcessingEngineCreateInfoARM
  {
    using NativeType = VkDataGraphProcessingEngineCreateInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphProcessingEngineCreateInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DataGraphProcessingEngineCreateInfoARM( uint32_t                                     processingEngineCount_ = {},
                                                                 PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines_    = {},
                                                                 void const *                                 pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , processingEngineCount{ processingEngineCount_ }
      , pProcessingEngines{ pProcessingEngines_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DataGraphProcessingEngineCreateInfoARM( DataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphProcessingEngineCreateInfoARM( VkDataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphProcessingEngineCreateInfoARM( *reinterpret_cast<DataGraphProcessingEngineCreateInfoARM const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphProcessingEngineCreateInfoARM( ArrayProxyNoTemporaries<PhysicalDeviceDataGraphProcessingEngineARM> const & processingEngines_,
                                            void const *                                                                pNext_ = nullptr )
      : pNext( pNext_ ), processingEngineCount( static_cast<uint32_t>( processingEngines_.size() ) ), pProcessingEngines( processingEngines_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DataGraphProcessingEngineCreateInfoARM & operator=( DataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphProcessingEngineCreateInfoARM & operator=( VkDataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphProcessingEngineCreateInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM & setProcessingEngineCount( uint32_t processingEngineCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      processingEngineCount = processingEngineCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM && setProcessingEngineCount( uint32_t processingEngineCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      processingEngineCount = processingEngineCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM & setPProcessingEngines( PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pProcessingEngines = pProcessingEngines_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM &&
      setPProcessingEngines( PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pProcessingEngines = pProcessingEngines_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DataGraphProcessingEngineCreateInfoARM &
      setProcessingEngines( ArrayProxyNoTemporaries<PhysicalDeviceDataGraphProcessingEngineARM> const & processingEngines_ ) VULKAN_HPP_NOEXCEPT
    {
      processingEngineCount = static_cast<uint32_t>( processingEngines_.size() );
      pProcessingEngines    = processingEngines_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDataGraphProcessingEngineCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphProcessingEngineCreateInfoARM const *>( this );
    }

    operator VkDataGraphProcessingEngineCreateInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphProcessingEngineCreateInfoARM *>( this );
    }

    operator VkDataGraphProcessingEngineCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphProcessingEngineCreateInfoARM const *>( this );
    }

    operator VkDataGraphProcessingEngineCreateInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphProcessingEngineCreateInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, PhysicalDeviceDataGraphProcessingEngineARM * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, processingEngineCount, pProcessingEngines );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DataGraphProcessingEngineCreateInfoARM const & ) const = default;
#else
    bool operator==( DataGraphProcessingEngineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( processingEngineCount == rhs.processingEngineCount ) &&
             ( pProcessingEngines == rhs.pProcessingEngines );
#  endif
    }

    bool operator!=( DataGraphProcessingEngineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                                sType                 = StructureType::eDataGraphProcessingEngineCreateInfoARM;
    void const *                                 pNext                 = {};
    uint32_t                                     processingEngineCount = {};
    PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphProcessingEngineCreateInfoARM>
  {
    using Type = DataGraphProcessingEngineCreateInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDataGraphProcessingEngineCreateInfoARM>
  {
    using Type = DataGraphProcessingEngineCreateInfoARM;
  };

  // wrapper struct for struct VkDataGraphTOSANameQualityARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphTOSANameQualityARM.html
  struct DataGraphTOSANameQualityARM
  {
    using NativeType = VkDataGraphTOSANameQualityARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 DataGraphTOSANameQualityARM( std::array<char, VK_MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM> const & name_         = {},
                                                         DataGraphTOSAQualityFlagsARM                                   qualityFlags_ = {} ) VULKAN_HPP_NOEXCEPT
      : name{ name_ }
      , qualityFlags{ qualityFlags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DataGraphTOSANameQualityARM( DataGraphTOSANameQualityARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DataGraphTOSANameQualityARM( VkDataGraphTOSANameQualityARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DataGraphTOSANameQualityARM( *reinterpret_cast<DataGraphTOSANameQualityARM const *>( &rhs ) )
    {
    }

    DataGraphTOSANameQualityARM & operator=( DataGraphTOSANameQualityARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DataGraphTOSANameQualityARM & operator=( VkDataGraphTOSANameQualityARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DataGraphTOSANameQualityARM const *>( &rhs );
      return *this;
    }

    operator VkDataGraphTOSANameQualityARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphTOSANameQualityARM const *>( this );
    }

    operator VkDataGraphTOSANameQualityARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDataGraphTOSANameQualityARM *>( this );
    }

    operator VkDataGraphTOSANameQualityARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphTOSANameQualityARM const *>( this );
    }

    operator VkDataGraphTOSANameQualityARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDataGraphTOSANameQualityARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<ArrayWrapper1D<char, VK_MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM> const &, DataGraphTOSAQualityFlagsARM const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( name, qualityFlags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( DataGraphTOSANameQualityARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 )
        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
      if ( auto cmp = qualityFlags <=> rhs.qualityFlags; cmp != 0 )
        return cmp;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( DataGraphTOSANameQualityARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( strcmp( name, rhs.name ) == 0 ) && ( qualityFlags == rhs.qualityFlags );
    }

    bool operator!=( DataGraphTOSANameQualityARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    ArrayWrapper1D<char, VK_MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM> name         = {};
    DataGraphTOSAQualityFlagsARM                               qualityFlags = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDataGraphTOSANameQualityARM>
  {
    using Type = DataGraphTOSANameQualityARM;
  };
#endif

  // wrapper struct for struct VkDebugMarkerMarkerInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugMarkerMarkerInfoEXT.html
  struct DebugMarkerMarkerInfoEXT
  {
    using NativeType = VkDebugMarkerMarkerInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDebugMarkerMarkerInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14
      DebugMarkerMarkerInfoEXT( char const * pMarkerName_ = {}, std::array<float, 4> const & color_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pMarkerName{ pMarkerName_ }
      , color{ color_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DebugMarkerMarkerInfoEXT( *reinterpret_cast<DebugMarkerMarkerInfoEXT const *>( &rhs ) )
    {
    }

    DebugMarkerMarkerInfoEXT & operator=( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DebugMarkerMarkerInfoEXT & operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DebugMarkerMarkerInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT & setPMarkerName( char const * pMarkerName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pMarkerName = pMarkerName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT && setPMarkerName( char const * pMarkerName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pMarkerName = pMarkerName_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT & setColor( std::array<float, 4> color_ ) & VULKAN_HPP_NOEXCEPT
    {
      color = color_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT && setColor( std::array<float, 4> color_ ) && VULKAN_HPP_NOEXCEPT
    {
      color = color_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT const *>( this );
    }

    operator VkDebugMarkerMarkerInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT *>( this );
    }

    operator VkDebugMarkerMarkerInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugMarkerMarkerInfoEXT const *>( this );
    }

    operator VkDebugMarkerMarkerInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugMarkerMarkerInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, char const * const &, ArrayWrapper1D<float, 4> const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pMarkerName, color );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::partial_ordering operator<=>( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( pMarkerName != rhs.pMarkerName )
        if ( auto cmp = strcmp( pMarkerName, rhs.pMarkerName ); cmp != 0 )
          return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater;
      if ( auto cmp = color <=> rhs.color; cmp != 0 )
        return cmp;

      return std::partial_ordering::equivalent;
    }
#endif

    bool operator==( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pMarkerName == rhs.pMarkerName ) || ( strcmp( pMarkerName, rhs.pMarkerName ) == 0 ) ) &&
             ( color == rhs.color );
    }

    bool operator!=( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType            sType       = StructureType::eDebugMarkerMarkerInfoEXT;
    void const *             pNext       = {};
    char const *             pMarkerName = {};
    ArrayWrapper1D<float, 4> color       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDebugMarkerMarkerInfoEXT>
  {
    using Type = DebugMarkerMarkerInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDebugMarkerMarkerInfoEXT>
  {
    using Type = DebugMarkerMarkerInfoEXT;
  };

  // wrapper struct for struct VkDebugMarkerObjectNameInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugMarkerObjectNameInfoEXT.html
  struct DebugMarkerObjectNameInfoEXT
  {
    using NativeType = VkDebugMarkerObjectNameInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDebugMarkerObjectNameInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_  = DebugReportObjectTypeEXT::eUnknown,
                                                       uint64_t                 object_      = {},
                                                       char const *             pObjectName_ = {},
                                                       void const *             pNext_       = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , objectType{ objectType_ }
      , object{ object_ }
      , pObjectName{ pObjectName_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DebugMarkerObjectNameInfoEXT( *reinterpret_cast<DebugMarkerObjectNameInfoEXT const *>( &rhs ) )
    {
    }

    DebugMarkerObjectNameInfoEXT & operator=( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DebugMarkerObjectNameInfoEXT & operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DebugMarkerObjectNameInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ ) & VULKAN_HPP_NOEXCEPT
    {
      objectType = objectType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setObjectType( DebugReportObjectTypeEXT objectType_ ) && VULKAN_HPP_NOEXCEPT
    {
      objectType = objectType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setObject( uint64_t object_ ) & VULKAN_HPP_NOEXCEPT
    {
      object = object_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setObject( uint64_t object_ ) && VULKAN_HPP_NOEXCEPT
    {
      object = object_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setPObjectName( char const * pObjectName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pObjectName = pObjectName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setPObjectName( char const * pObjectName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pObjectName = pObjectName_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT const *>( this );
    }

    operator VkDebugMarkerObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>( this );
    }

    operator VkDebugMarkerObjectNameInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT const *>( this );
    }

    operator VkDebugMarkerObjectNameInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DebugReportObjectTypeEXT const &, uint64_t const &, char const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, objectType, object, pObjectName );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( auto cmp = objectType <=> rhs.objectType; cmp != 0 )
        return cmp;
      if ( auto cmp = object <=> rhs.object; cmp != 0 )
        return cmp;
      if ( pObjectName != rhs.pObjectName )
        if ( auto cmp = strcmp( pObjectName, rhs.pObjectName ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( object == rhs.object ) &&
             ( ( pObjectName == rhs.pObjectName ) || ( strcmp( pObjectName, rhs.pObjectName ) == 0 ) );
    }

    bool operator!=( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType            sType       = StructureType::eDebugMarkerObjectNameInfoEXT;
    void const *             pNext       = {};
    DebugReportObjectTypeEXT objectType  = DebugReportObjectTypeEXT::eUnknown;
    uint64_t                 object      = {};
    char const *             pObjectName = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDebugMarkerObjectNameInfoEXT>
  {
    using Type = DebugMarkerObjectNameInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDebugMarkerObjectNameInfoEXT>
  {
    using Type = DebugMarkerObjectNameInfoEXT;
  };

  // wrapper struct for struct VkDebugMarkerObjectTagInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugMarkerObjectTagInfoEXT.html
  struct DebugMarkerObjectTagInfoEXT
  {
    using NativeType = VkDebugMarkerObjectTagInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDebugMarkerObjectTagInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
                                                      uint64_t                 object_     = {},
                                                      uint64_t                 tagName_    = {},
                                                      size_t                   tagSize_    = {},
                                                      void const *             pTag_       = {},
                                                      void const *             pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , objectType{ objectType_ }
      , object{ object_ }
      , tagName{ tagName_ }
      , tagSize{ tagSize_ }
      , pTag{ pTag_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DebugMarkerObjectTagInfoEXT( *reinterpret_cast<DebugMarkerObjectTagInfoEXT const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    DebugMarkerObjectTagInfoEXT(
      DebugReportObjectTypeEXT objectType_, uint64_t object_, uint64_t tagName_, ArrayProxyNoTemporaries<T const> const & tag_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), objectType( objectType_ ), object( object_ ), tagName( tagName_ ), tagSize( tag_.size() * sizeof( T ) ), pTag( tag_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DebugMarkerObjectTagInfoEXT & operator=( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DebugMarkerObjectTagInfoEXT & operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DebugMarkerObjectTagInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ ) & VULKAN_HPP_NOEXCEPT
    {
      objectType = objectType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setObjectType( DebugReportObjectTypeEXT objectType_ ) && VULKAN_HPP_NOEXCEPT
    {
      objectType = objectType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setObject( uint64_t object_ ) & VULKAN_HPP_NOEXCEPT
    {
      object = object_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setObject( uint64_t object_ ) && VULKAN_HPP_NOEXCEPT
    {
      object = object_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setTagName( uint64_t tagName_ ) & VULKAN_HPP_NOEXCEPT
    {
      tagName = tagName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setTagName( uint64_t tagName_ ) && VULKAN_HPP_NOEXCEPT
    {
      tagName = tagName_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setTagSize( size_t tagSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      tagSize = tagSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setTagSize( size_t tagSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      tagSize = tagSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setPTag( void const * pTag_ ) & VULKAN_HPP_NOEXCEPT
    {
      pTag = pTag_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setPTag( void const * pTag_ ) && VULKAN_HPP_NOEXCEPT
    {
      pTag = pTag_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    DebugMarkerObjectTagInfoEXT & setTag( ArrayProxyNoTemporaries<T const> const & tag_ ) VULKAN_HPP_NOEXCEPT
    {
      tagSize = tag_.size() * sizeof( T );
      pTag    = tag_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT const *>( this );
    }

    operator VkDebugMarkerObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>( this );
    }

    operator VkDebugMarkerObjectTagInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT const *>( this );
    }

    operator VkDebugMarkerObjectTagInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DebugReportObjectTypeEXT const &,
               uint64_t const &,
               uint64_t const &,
               size_t const &,
               void const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DebugMarkerObjectTagInfoEXT const & ) const = default;
#else
    bool operator==( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( object == rhs.object ) && ( tagName == rhs.tagName ) &&
             ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag );
#  endif
    }

    bool operator!=( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType            sType      = StructureType::eDebugMarkerObjectTagInfoEXT;
    void const *             pNext      = {};
    DebugReportObjectTypeEXT objectType = DebugReportObjectTypeEXT::eUnknown;
    uint64_t                 object     = {};
    uint64_t                 tagName    = {};
    size_t                   tagSize    = {};
    void const *             pTag       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDebugMarkerObjectTagInfoEXT>
  {
    using Type = DebugMarkerObjectTagInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDebugMarkerObjectTagInfoEXT>
  {
    using Type = DebugMarkerObjectTagInfoEXT;
  };

  typedef Bool32( VKAPI_PTR * PFN_DebugReportCallbackEXT )( DebugReportFlagsEXT      flags,
                                                            DebugReportObjectTypeEXT objectType,
                                                            uint64_t                 object,
                                                            size_t                   location,
                                                            int32_t                  messageCode,
                                                            char const *             pLayerPrefix,
                                                            char const *             pMessage,
                                                            void *                   pUserData );

  // wrapper struct for struct VkDebugReportCallbackCreateInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackCreateInfoEXT.html
  struct DebugReportCallbackCreateInfoEXT
  {
    using NativeType = VkDebugReportCallbackCreateInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDebugReportCallbackCreateInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT        flags_       = {},
                                                           PFN_DebugReportCallbackEXT pfnCallback_ = {},
                                                           void *                     pUserData_   = {},
                                                           void const *               pNext_       = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , pfnCallback{ pfnCallback_ }
      , pUserData{ pUserData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DebugReportCallbackCreateInfoEXT( *reinterpret_cast<DebugReportCallbackCreateInfoEXT const *>( &rhs ) )
    {
    }

#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic push
#    if defined( __clang__ )
#      pragma clang diagnostic ignored "-Wunknown-warning-option"
#    endif
#    pragma GCC diagnostic ignored "-Wcast-function-type"
#  endif
    VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." )

    DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT          flags_,
                                      PFN_vkDebugReportCallbackEXT pfnCallback_,
                                      void *                       pUserData_ = {},
                                      const void *                 pNext_     = nullptr ) VULKAN_HPP_NOEXCEPT
      : DebugReportCallbackCreateInfoEXT( flags_, reinterpret_cast<PFN_DebugReportCallbackEXT>( pfnCallback_ ), pUserData_, pNext_ )
    {
    }
#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic pop
#  endif

    DebugReportCallbackCreateInfoEXT & operator=( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DebugReportCallbackCreateInfoEXT & operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DebugReportCallbackCreateInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setFlags( DebugReportFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setFlags( DebugReportFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_DebugReportCallbackEXT pfnCallback_ ) & VULKAN_HPP_NOEXCEPT
    {
      pfnCallback = pfnCallback_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setPfnCallback( PFN_DebugReportCallbackEXT pfnCallback_ ) && VULKAN_HPP_NOEXCEPT
    {
      pfnCallback = pfnCallback_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT
    {
      pUserData = pUserData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT
    {
      pUserData = pUserData_;
      return std::move( *this );
    }

#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic push
#    if defined( __clang__ )
#      pragma clang diagnostic ignored "-Wunknown-warning-option"
#    endif
#    pragma GCC diagnostic ignored "-Wcast-function-type"
#  endif
    VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )

    DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT
    {
      return setPfnCallback( reinterpret_cast<PFN_DebugReportCallbackEXT>( pfnCallback_ ) );
    }
#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic pop
#  endif
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT const *>( this );
    }

    operator VkDebugReportCallbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>( this );
    }

    operator VkDebugReportCallbackCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT const *>( this );
    }

    operator VkDebugReportCallbackCreateInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DebugReportFlagsEXT const &, PFN_DebugReportCallbackEXT const &, void * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, pfnCallback, pUserData );
    }
#endif

    bool operator==( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData );
#endif
    }

    bool operator!=( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType              sType       = StructureType::eDebugReportCallbackCreateInfoEXT;
    void const *               pNext       = {};
    DebugReportFlagsEXT        flags       = {};
    PFN_DebugReportCallbackEXT pfnCallback = {};
    void *                     pUserData   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDebugReportCallbackCreateInfoEXT>
  {
    using Type = DebugReportCallbackCreateInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDebugReportCallbackCreateInfoEXT>
  {
    using Type = DebugReportCallbackCreateInfoEXT;
  };

  // wrapper struct for struct VkDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsLabelEXT.html
  struct DebugUtilsLabelEXT
  {
    using NativeType = VkDebugUtilsLabelEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDebugUtilsLabelEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14
      DebugUtilsLabelEXT( char const * pLabelName_ = {}, std::array<float, 4> const & color_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pLabelName{ pLabelName_ }
      , color{ color_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DebugUtilsLabelEXT( *reinterpret_cast<DebugUtilsLabelEXT const *>( &rhs ) ) {}

    DebugUtilsLabelEXT & operator=( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DebugUtilsLabelEXT & operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DebugUtilsLabelEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT & setPLabelName( char const * pLabelName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pLabelName = pLabelName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT && setPLabelName( char const * pLabelName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pLabelName = pLabelName_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT & setColor( std::array<float, 4> color_ ) & VULKAN_HPP_NOEXCEPT
    {
      color = color_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT && setColor( std::array<float, 4> color_ ) && VULKAN_HPP_NOEXCEPT
    {
      color = color_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsLabelEXT const *>( this );
    }

    operator VkDebugUtilsLabelEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsLabelEXT *>( this );
    }

    operator VkDebugUtilsLabelEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsLabelEXT const *>( this );
    }

    operator VkDebugUtilsLabelEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsLabelEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, char const * const &, ArrayWrapper1D<float, 4> const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pLabelName, color );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::partial_ordering operator<=>( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( pLabelName != rhs.pLabelName )
        if ( auto cmp = strcmp( pLabelName, rhs.pLabelName ); cmp != 0 )
          return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater;
      if ( auto cmp = color <=> rhs.color; cmp != 0 )
        return cmp;

      return std::partial_ordering::equivalent;
    }
#endif

    bool operator==( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pLabelName == rhs.pLabelName ) || ( strcmp( pLabelName, rhs.pLabelName ) == 0 ) ) &&
             ( color == rhs.color );
    }

    bool operator!=( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType            sType      = StructureType::eDebugUtilsLabelEXT;
    void const *             pNext      = {};
    char const *             pLabelName = {};
    ArrayWrapper1D<float, 4> color      = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDebugUtilsLabelEXT>
  {
    using Type = DebugUtilsLabelEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDebugUtilsLabelEXT>
  {
    using Type = DebugUtilsLabelEXT;
  };

  // wrapper struct for struct VkDebugUtilsObjectNameInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsObjectNameInfoEXT.html
  struct DebugUtilsObjectNameInfoEXT
  {
    using NativeType = VkDebugUtilsObjectNameInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDebugUtilsObjectNameInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( ObjectType   objectType_   = ObjectType::eUnknown,
                                                      uint64_t     objectHandle_ = {},
                                                      char const * pObjectName_  = {},
                                                      void const * pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , objectType{ objectType_ }
      , objectHandle{ objectHandle_ }
      , pObjectName{ pObjectName_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DebugUtilsObjectNameInfoEXT( *reinterpret_cast<DebugUtilsObjectNameInfoEXT const *>( &rhs ) )
    {
    }

    DebugUtilsObjectNameInfoEXT & operator=( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DebugUtilsObjectNameInfoEXT & operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DebugUtilsObjectNameInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setObjectType( ObjectType objectType_ ) & VULKAN_HPP_NOEXCEPT
    {
      objectType = objectType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setObjectType( ObjectType objectType_ ) && VULKAN_HPP_NOEXCEPT
    {
      objectType = objectType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setObjectHandle( uint64_t objectHandle_ ) & VULKAN_HPP_NOEXCEPT
    {
      objectHandle = objectHandle_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setObjectHandle( uint64_t objectHandle_ ) && VULKAN_HPP_NOEXCEPT
    {
      objectHandle = objectHandle_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setPObjectName( char const * pObjectName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pObjectName = pObjectName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setPObjectName( char const * pObjectName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pObjectName = pObjectName_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT const *>( this );
    }

    operator VkDebugUtilsObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT *>( this );
    }

    operator VkDebugUtilsObjectNameInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT const *>( this );
    }

    operator VkDebugUtilsObjectNameInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, ObjectType const &, uint64_t const &, char const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, objectType, objectHandle, pObjectName );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( auto cmp = objectType <=> rhs.objectType; cmp != 0 )
        return cmp;
      if ( auto cmp = objectHandle <=> rhs.objectHandle; cmp != 0 )
        return cmp;
      if ( pObjectName != rhs.pObjectName )
        if ( auto cmp = strcmp( pObjectName, rhs.pObjectName ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) &&
             ( ( pObjectName == rhs.pObjectName ) || ( strcmp( pObjectName, rhs.pObjectName ) == 0 ) );
    }

    bool operator!=( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType sType        = StructureType::eDebugUtilsObjectNameInfoEXT;
    void const *  pNext        = {};
    ObjectType    objectType   = ObjectType::eUnknown;
    uint64_t      objectHandle = {};
    char const *  pObjectName  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDebugUtilsObjectNameInfoEXT>
  {
    using Type = DebugUtilsObjectNameInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDebugUtilsObjectNameInfoEXT>
  {
    using Type = DebugUtilsObjectNameInfoEXT;
  };

  // wrapper struct for struct VkDebugUtilsMessengerCallbackDataEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCallbackDataEXT.html
  struct DebugUtilsMessengerCallbackDataEXT
  {
    using NativeType = VkDebugUtilsMessengerCallbackDataEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDebugUtilsMessengerCallbackDataEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_            = {},
                                                                char const *                            pMessageIdName_   = {},
                                                                int32_t                                 messageIdNumber_  = {},
                                                                char const *                            pMessage_         = {},
                                                                uint32_t                                queueLabelCount_  = {},
                                                                DebugUtilsLabelEXT const *              pQueueLabels_     = {},
                                                                uint32_t                                cmdBufLabelCount_ = {},
                                                                DebugUtilsLabelEXT const *              pCmdBufLabels_    = {},
                                                                uint32_t                                objectCount_      = {},
                                                                DebugUtilsObjectNameInfoEXT const *     pObjects_         = {},
                                                                void const *                            pNext_            = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , pMessageIdName{ pMessageIdName_ }
      , messageIdNumber{ messageIdNumber_ }
      , pMessage{ pMessage_ }
      , queueLabelCount{ queueLabelCount_ }
      , pQueueLabels{ pQueueLabels_ }
      , cmdBufLabelCount{ cmdBufLabelCount_ }
      , pCmdBufLabels{ pCmdBufLabels_ }
      , objectCount{ objectCount_ }
      , pObjects{ pObjects_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DebugUtilsMessengerCallbackDataEXT( *reinterpret_cast<DebugUtilsMessengerCallbackDataEXT const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT                            flags_,
                                        char const *                                                       pMessageIdName_,
                                        int32_t                                                            messageIdNumber_,
                                        char const *                                                       pMessage_,
                                        ArrayProxyNoTemporaries<DebugUtilsLabelEXT const> const &          queueLabels_,
                                        ArrayProxyNoTemporaries<DebugUtilsLabelEXT const> const &          cmdBufLabels_ = {},
                                        ArrayProxyNoTemporaries<DebugUtilsObjectNameInfoEXT const> const & objects_      = {},
                                        void const *                                                       pNext_        = nullptr )
      : pNext( pNext_ )
      , flags( flags_ )
      , pMessageIdName( pMessageIdName_ )
      , messageIdNumber( messageIdNumber_ )
      , pMessage( pMessage_ )
      , queueLabelCount( static_cast<uint32_t>( queueLabels_.size() ) )
      , pQueueLabels( queueLabels_.data() )
      , cmdBufLabelCount( static_cast<uint32_t>( cmdBufLabels_.size() ) )
      , pCmdBufLabels( cmdBufLabels_.data() )
      , objectCount( static_cast<uint32_t>( objects_.size() ) )
      , pObjects( objects_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DebugUtilsMessengerCallbackDataEXT & operator=( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DebugUtilsMessengerCallbackDataEXT & operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DebugUtilsMessengerCallbackDataEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPMessageIdName( char const * pMessageIdName_ ) & VULKAN_HPP_NOEXCEPT
    {
      pMessageIdName = pMessageIdName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPMessageIdName( char const * pMessageIdName_ ) && VULKAN_HPP_NOEXCEPT
    {
      pMessageIdName = pMessageIdName_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setMessageIdNumber( int32_t messageIdNumber_ ) & VULKAN_HPP_NOEXCEPT
    {
      messageIdNumber = messageIdNumber_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setMessageIdNumber( int32_t messageIdNumber_ ) && VULKAN_HPP_NOEXCEPT
    {
      messageIdNumber = messageIdNumber_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPMessage( char const * pMessage_ ) & VULKAN_HPP_NOEXCEPT
    {
      pMessage = pMessage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPMessage( char const * pMessage_ ) && VULKAN_HPP_NOEXCEPT
    {
      pMessage = pMessage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setQueueLabelCount( uint32_t queueLabelCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      queueLabelCount = queueLabelCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setQueueLabelCount( uint32_t queueLabelCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      queueLabelCount = queueLabelCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPQueueLabels( DebugUtilsLabelEXT const * pQueueLabels_ ) & VULKAN_HPP_NOEXCEPT
    {
      pQueueLabels = pQueueLabels_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPQueueLabels( DebugUtilsLabelEXT const * pQueueLabels_ ) && VULKAN_HPP_NOEXCEPT
    {
      pQueueLabels = pQueueLabels_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DebugUtilsMessengerCallbackDataEXT & setQueueLabels( ArrayProxyNoTemporaries<DebugUtilsLabelEXT const> const & queueLabels_ ) VULKAN_HPP_NOEXCEPT
    {
      queueLabelCount = static_cast<uint32_t>( queueLabels_.size() );
      pQueueLabels    = queueLabels_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      cmdBufLabelCount = cmdBufLabelCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      cmdBufLabelCount = cmdBufLabelCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels( DebugUtilsLabelEXT const * pCmdBufLabels_ ) & VULKAN_HPP_NOEXCEPT
    {
      pCmdBufLabels = pCmdBufLabels_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPCmdBufLabels( DebugUtilsLabelEXT const * pCmdBufLabels_ ) && VULKAN_HPP_NOEXCEPT
    {
      pCmdBufLabels = pCmdBufLabels_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DebugUtilsMessengerCallbackDataEXT & setCmdBufLabels( ArrayProxyNoTemporaries<DebugUtilsLabelEXT const> const & cmdBufLabels_ ) VULKAN_HPP_NOEXCEPT
    {
      cmdBufLabelCount = static_cast<uint32_t>( cmdBufLabels_.size() );
      pCmdBufLabels    = cmdBufLabels_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setObjectCount( uint32_t objectCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      objectCount = objectCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setObjectCount( uint32_t objectCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      objectCount = objectCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPObjects( DebugUtilsObjectNameInfoEXT const * pObjects_ ) & VULKAN_HPP_NOEXCEPT
    {
      pObjects = pObjects_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPObjects( DebugUtilsObjectNameInfoEXT const * pObjects_ ) && VULKAN_HPP_NOEXCEPT
    {
      pObjects = pObjects_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DebugUtilsMessengerCallbackDataEXT & setObjects( ArrayProxyNoTemporaries<DebugUtilsObjectNameInfoEXT const> const & objects_ ) VULKAN_HPP_NOEXCEPT
    {
      objectCount = static_cast<uint32_t>( objects_.size() );
      pObjects    = objects_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT const *>( this );
    }

    operator VkDebugUtilsMessengerCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT *>( this );
    }

    operator VkDebugUtilsMessengerCallbackDataEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT const *>( this );
    }

    operator VkDebugUtilsMessengerCallbackDataEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DebugUtilsMessengerCallbackDataFlagsEXT const &,
               char const * const &,
               int32_t const &,
               char const * const &,
               uint32_t const &,
               DebugUtilsLabelEXT const * const &,
               uint32_t const &,
               DebugUtilsLabelEXT const * const &,
               uint32_t const &,
               DebugUtilsObjectNameInfoEXT const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie(
        sType, pNext, flags, pMessageIdName, messageIdNumber, pMessage, queueLabelCount, pQueueLabels, cmdBufLabelCount, pCmdBufLabels, objectCount, pObjects );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    std::strong_ordering operator<=>( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
        return cmp;
      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
        return cmp;
      if ( auto cmp = flags <=> rhs.flags; cmp != 0 )
        return cmp;
      if ( pMessageIdName != rhs.pMessageIdName )
        if ( auto cmp = strcmp( pMessageIdName, rhs.pMessageIdName ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
      if ( auto cmp = messageIdNumber <=> rhs.messageIdNumber; cmp != 0 )
        return cmp;
      if ( pMessage != rhs.pMessage )
        if ( auto cmp = strcmp( pMessage, rhs.pMessage ); cmp != 0 )
          return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
      if ( auto cmp = queueLabelCount <=> rhs.queueLabelCount; cmp != 0 )
        return cmp;
      if ( auto cmp = pQueueLabels <=> rhs.pQueueLabels; cmp != 0 )
        return cmp;
      if ( auto cmp = cmdBufLabelCount <=> rhs.cmdBufLabelCount; cmp != 0 )
        return cmp;
      if ( auto cmp = pCmdBufLabels <=> rhs.pCmdBufLabels; cmp != 0 )
        return cmp;
      if ( auto cmp = objectCount <=> rhs.objectCount; cmp != 0 )
        return cmp;
      if ( auto cmp = pObjects <=> rhs.pObjects; cmp != 0 )
        return cmp;

      return std::strong_ordering::equivalent;
    }
#endif

    bool operator==( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
             ( ( pMessageIdName == rhs.pMessageIdName ) || ( strcmp( pMessageIdName, rhs.pMessageIdName ) == 0 ) ) &&
             ( messageIdNumber == rhs.messageIdNumber ) && ( ( pMessage == rhs.pMessage ) || ( strcmp( pMessage, rhs.pMessage ) == 0 ) ) &&
             ( queueLabelCount == rhs.queueLabelCount ) && ( pQueueLabels == rhs.pQueueLabels ) && ( cmdBufLabelCount == rhs.cmdBufLabelCount ) &&
             ( pCmdBufLabels == rhs.pCmdBufLabels ) && ( objectCount == rhs.objectCount ) && ( pObjects == rhs.pObjects );
    }

    bool operator!=( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType                           sType            = StructureType::eDebugUtilsMessengerCallbackDataEXT;
    void const *                            pNext            = {};
    DebugUtilsMessengerCallbackDataFlagsEXT flags            = {};
    char const *                            pMessageIdName   = {};
    int32_t                                 messageIdNumber  = {};
    char const *                            pMessage         = {};
    uint32_t                                queueLabelCount  = {};
    DebugUtilsLabelEXT const *              pQueueLabels     = {};
    uint32_t                                cmdBufLabelCount = {};
    DebugUtilsLabelEXT const *              pCmdBufLabels    = {};
    uint32_t                                objectCount      = {};
    DebugUtilsObjectNameInfoEXT const *     pObjects         = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDebugUtilsMessengerCallbackDataEXT>
  {
    using Type = DebugUtilsMessengerCallbackDataEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDebugUtilsMessengerCallbackDataEXT>
  {
    using Type = DebugUtilsMessengerCallbackDataEXT;
  };

  typedef Bool32( VKAPI_PTR * PFN_DebugUtilsMessengerCallbackEXT )( DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
                                                                    DebugUtilsMessageTypeFlagsEXT              messageTypes,
                                                                    DebugUtilsMessengerCallbackDataEXT const * pCallbackData,
                                                                    void *                                     pUserData );

  // wrapper struct for struct VkDebugUtilsMessengerCreateInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCreateInfoEXT.html
  struct DebugUtilsMessengerCreateInfoEXT
  {
    using NativeType = VkDebugUtilsMessengerCreateInfoEXT;

    static bool const                                  allowDuplicate = true;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDebugUtilsMessengerCreateInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT  flags_           = {},
                                                           DebugUtilsMessageSeverityFlagsEXT  messageSeverity_ = {},
                                                           DebugUtilsMessageTypeFlagsEXT      messageType_     = {},
                                                           PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ = {},
                                                           void *                             pUserData_       = {},
                                                           void const *                       pNext_           = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , messageSeverity{ messageSeverity_ }
      , messageType{ messageType_ }
      , pfnUserCallback{ pfnUserCallback_ }
      , pUserData{ pUserData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DebugUtilsMessengerCreateInfoEXT( *reinterpret_cast<DebugUtilsMessengerCreateInfoEXT const *>( &rhs ) )
    {
    }

#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic push
#    if defined( __clang__ )
#      pragma clang diagnostic ignored "-Wunknown-warning-option"
#    endif
#    pragma GCC diagnostic ignored "-Wcast-function-type"
#  endif
    VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." )

    DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT    flags_,
                                      DebugUtilsMessageSeverityFlagsEXT    messageSeverity_,
                                      DebugUtilsMessageTypeFlagsEXT        messageType_,
                                      PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_,
                                      void *                               pUserData_ = {},
                                      const void *                         pNext_     = nullptr ) VULKAN_HPP_NOEXCEPT
      : DebugUtilsMessengerCreateInfoEXT(
          flags_, messageSeverity_, messageType_, reinterpret_cast<PFN_DebugUtilsMessengerCallbackEXT>( pfnUserCallback_ ), pUserData_, pNext_ )
    {
    }
#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic pop
#  endif

    DebugUtilsMessengerCreateInfoEXT & operator=( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DebugUtilsMessengerCreateInfoEXT & operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DebugUtilsMessengerCreateInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ ) & VULKAN_HPP_NOEXCEPT
    {
      messageSeverity = messageSeverity_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ ) && VULKAN_HPP_NOEXCEPT
    {
      messageSeverity = messageSeverity_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ ) & VULKAN_HPP_NOEXCEPT
    {
      messageType = messageType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ ) && VULKAN_HPP_NOEXCEPT
    {
      messageType = messageType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ ) & VULKAN_HPP_NOEXCEPT
    {
      pfnUserCallback = pfnUserCallback_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setPfnUserCallback( PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ ) && VULKAN_HPP_NOEXCEPT
    {
      pfnUserCallback = pfnUserCallback_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT
    {
      pUserData = pUserData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT
    {
      pUserData = pUserData_;
      return std::move( *this );
    }

#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic push
#    if defined( __clang__ )
#      pragma clang diagnostic ignored "-Wunknown-warning-option"
#    endif
#    pragma GCC diagnostic ignored "-Wcast-function-type"
#  endif
    VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )

    DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT
    {
      return setPfnUserCallback( reinterpret_cast<PFN_DebugUtilsMessengerCallbackEXT>( pfnUserCallback_ ) );
    }
#  if defined( __clang__ ) || defined( __GNUC__ )
#    pragma GCC diagnostic pop
#  endif
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT const *>( this );
    }

    operator VkDebugUtilsMessengerCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT *>( this );
    }

    operator VkDebugUtilsMessengerCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT const *>( this );
    }

    operator VkDebugUtilsMessengerCreateInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DebugUtilsMessengerCreateFlagsEXT const &,
               DebugUtilsMessageSeverityFlagsEXT const &,
               DebugUtilsMessageTypeFlagsEXT const &,
               PFN_DebugUtilsMessengerCallbackEXT const &,
               void * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData );
    }
#endif

    bool operator==( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( messageSeverity == rhs.messageSeverity ) &&
             ( messageType == rhs.messageType ) && ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData );
#endif
    }

    bool operator!=( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }

  public:
    StructureType                      sType           = StructureType::eDebugUtilsMessengerCreateInfoEXT;
    void const *                       pNext           = {};
    DebugUtilsMessengerCreateFlagsEXT  flags           = {};
    DebugUtilsMessageSeverityFlagsEXT  messageSeverity = {};
    DebugUtilsMessageTypeFlagsEXT      messageType     = {};
    PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback = {};
    void *                             pUserData       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDebugUtilsMessengerCreateInfoEXT>
  {
    using Type = DebugUtilsMessengerCreateInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDebugUtilsMessengerCreateInfoEXT>
  {
    using Type = DebugUtilsMessengerCreateInfoEXT;
  };

  // wrapper struct for struct VkDebugUtilsObjectTagInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsObjectTagInfoEXT.html
  struct DebugUtilsObjectTagInfoEXT
  {
    using NativeType = VkDebugUtilsObjectTagInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDebugUtilsObjectTagInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( ObjectType   objectType_   = ObjectType::eUnknown,
                                                     uint64_t     objectHandle_ = {},
                                                     uint64_t     tagName_      = {},
                                                     size_t       tagSize_      = {},
                                                     void const * pTag_         = {},
                                                     void const * pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , objectType{ objectType_ }
      , objectHandle{ objectHandle_ }
      , tagName{ tagName_ }
      , tagSize{ tagSize_ }
      , pTag{ pTag_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DebugUtilsObjectTagInfoEXT( *reinterpret_cast<DebugUtilsObjectTagInfoEXT const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    DebugUtilsObjectTagInfoEXT(
      ObjectType objectType_, uint64_t objectHandle_, uint64_t tagName_, ArrayProxyNoTemporaries<T const> const & tag_, void const * pNext_ = nullptr )
      : pNext( pNext_ )
      , objectType( objectType_ )
      , objectHandle( objectHandle_ )
      , tagName( tagName_ )
      , tagSize( tag_.size() * sizeof( T ) )
      , pTag( tag_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DebugUtilsObjectTagInfoEXT & operator=( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DebugUtilsObjectTagInfoEXT & operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DebugUtilsObjectTagInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setObjectType( ObjectType objectType_ ) & VULKAN_HPP_NOEXCEPT
    {
      objectType = objectType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setObjectType( ObjectType objectType_ ) && VULKAN_HPP_NOEXCEPT
    {
      objectType = objectType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setObjectHandle( uint64_t objectHandle_ ) & VULKAN_HPP_NOEXCEPT
    {
      objectHandle = objectHandle_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setObjectHandle( uint64_t objectHandle_ ) && VULKAN_HPP_NOEXCEPT
    {
      objectHandle = objectHandle_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setTagName( uint64_t tagName_ ) & VULKAN_HPP_NOEXCEPT
    {
      tagName = tagName_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setTagName( uint64_t tagName_ ) && VULKAN_HPP_NOEXCEPT
    {
      tagName = tagName_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setTagSize( size_t tagSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      tagSize = tagSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setTagSize( size_t tagSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      tagSize = tagSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setPTag( void const * pTag_ ) & VULKAN_HPP_NOEXCEPT
    {
      pTag = pTag_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setPTag( void const * pTag_ ) && VULKAN_HPP_NOEXCEPT
    {
      pTag = pTag_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    template <typename T>
    DebugUtilsObjectTagInfoEXT & setTag( ArrayProxyNoTemporaries<T const> const & tag_ ) VULKAN_HPP_NOEXCEPT
    {
      tagSize = tag_.size() * sizeof( T );
      pTag    = tag_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT const *>( this );
    }

    operator VkDebugUtilsObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT *>( this );
    }

    operator VkDebugUtilsObjectTagInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsObjectTagInfoEXT const *>( this );
    }

    operator VkDebugUtilsObjectTagInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDebugUtilsObjectTagInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, ObjectType const &, uint64_t const &, uint64_t const &, size_t const &, void const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DebugUtilsObjectTagInfoEXT const & ) const = default;
#else
    bool operator==( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) &&
             ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag );
#  endif
    }

    bool operator!=( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType        = StructureType::eDebugUtilsObjectTagInfoEXT;
    void const *  pNext        = {};
    ObjectType    objectType   = ObjectType::eUnknown;
    uint64_t      objectHandle = {};
    uint64_t      tagName      = {};
    size_t        tagSize      = {};
    void const *  pTag         = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDebugUtilsObjectTagInfoEXT>
  {
    using Type = DebugUtilsObjectTagInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDebugUtilsObjectTagInfoEXT>
  {
    using Type = DebugUtilsObjectTagInfoEXT;
  };

  // wrapper struct for struct VkDecompressMemoryRegionEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDecompressMemoryRegionEXT.html
  struct DecompressMemoryRegionEXT
  {
    using NativeType = VkDecompressMemoryRegionEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DecompressMemoryRegionEXT( DeviceAddress srcAddress_       = {},
                                                    DeviceAddress dstAddress_       = {},
                                                    DeviceSize    compressedSize_   = {},
                                                    DeviceSize    decompressedSize_ = {} ) VULKAN_HPP_NOEXCEPT
      : srcAddress{ srcAddress_ }
      , dstAddress{ dstAddress_ }
      , compressedSize{ compressedSize_ }
      , decompressedSize{ decompressedSize_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DecompressMemoryRegionEXT( DecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DecompressMemoryRegionEXT( VkDecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DecompressMemoryRegionEXT( *reinterpret_cast<DecompressMemoryRegionEXT const *>( &rhs ) )
    {
    }

    DecompressMemoryRegionEXT & operator=( DecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DecompressMemoryRegionEXT & operator=( VkDecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DecompressMemoryRegionEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcAddress = srcAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcAddress = srcAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setDstAddress( DeviceAddress dstAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstAddress = dstAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setDstAddress( DeviceAddress dstAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstAddress = dstAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setCompressedSize( DeviceSize compressedSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      compressedSize = compressedSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setCompressedSize( DeviceSize compressedSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      compressedSize = compressedSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setDecompressedSize( DeviceSize decompressedSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      decompressedSize = decompressedSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setDecompressedSize( DeviceSize decompressedSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      decompressedSize = decompressedSize_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDecompressMemoryRegionEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDecompressMemoryRegionEXT const *>( this );
    }

    operator VkDecompressMemoryRegionEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDecompressMemoryRegionEXT *>( this );
    }

    operator VkDecompressMemoryRegionEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDecompressMemoryRegionEXT const *>( this );
    }

    operator VkDecompressMemoryRegionEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDecompressMemoryRegionEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, DeviceAddress const &, DeviceSize const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( srcAddress, dstAddress, compressedSize, decompressedSize );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DecompressMemoryRegionEXT const & ) const = default;
#else
    bool operator==( DecompressMemoryRegionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( srcAddress == rhs.srcAddress ) && ( dstAddress == rhs.dstAddress ) && ( compressedSize == rhs.compressedSize ) &&
             ( decompressedSize == rhs.decompressedSize );
#  endif
    }

    bool operator!=( DecompressMemoryRegionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress srcAddress       = {};
    DeviceAddress dstAddress       = {};
    DeviceSize    compressedSize   = {};
    DeviceSize    decompressedSize = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDecompressMemoryRegionEXT>
  {
    using Type = DecompressMemoryRegionEXT;
  };
#endif

  // wrapper struct for struct VkDecompressMemoryInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDecompressMemoryInfoEXT.html
  struct DecompressMemoryInfoEXT
  {
    using NativeType = VkDecompressMemoryInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDecompressMemoryInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DecompressMemoryInfoEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod_ = {},
                                                  uint32_t                          regionCount_         = {},
                                                  DecompressMemoryRegionEXT const * pRegions_            = {},
                                                  void const *                      pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , decompressionMethod{ decompressionMethod_ }
      , regionCount{ regionCount_ }
      , pRegions{ pRegions_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DecompressMemoryInfoEXT( DecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DecompressMemoryInfoEXT( VkDecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DecompressMemoryInfoEXT( *reinterpret_cast<DecompressMemoryInfoEXT const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DecompressMemoryInfoEXT( MemoryDecompressionMethodFlagsEXT                                decompressionMethod_,
                             ArrayProxyNoTemporaries<DecompressMemoryRegionEXT const> const & regions_,
                             void const *                                                     pNext_ = nullptr )
      : pNext( pNext_ ), decompressionMethod( decompressionMethod_ ), regionCount( static_cast<uint32_t>( regions_.size() ) ), pRegions( regions_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DecompressMemoryInfoEXT & operator=( DecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DecompressMemoryInfoEXT & operator=( VkDecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DecompressMemoryInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setDecompressionMethod( MemoryDecompressionMethodFlagsEXT decompressionMethod_ ) & VULKAN_HPP_NOEXCEPT
    {
      decompressionMethod = decompressionMethod_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setDecompressionMethod( MemoryDecompressionMethodFlagsEXT decompressionMethod_ ) && VULKAN_HPP_NOEXCEPT
    {
      decompressionMethod = decompressionMethod_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      regionCount = regionCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setPRegions( DecompressMemoryRegionEXT const * pRegions_ ) & VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setPRegions( DecompressMemoryRegionEXT const * pRegions_ ) && VULKAN_HPP_NOEXCEPT
    {
      pRegions = pRegions_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DecompressMemoryInfoEXT & setRegions( ArrayProxyNoTemporaries<DecompressMemoryRegionEXT const> const & regions_ ) VULKAN_HPP_NOEXCEPT
    {
      regionCount = static_cast<uint32_t>( regions_.size() );
      pRegions    = regions_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDecompressMemoryInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDecompressMemoryInfoEXT const *>( this );
    }

    operator VkDecompressMemoryInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDecompressMemoryInfoEXT *>( this );
    }

    operator VkDecompressMemoryInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDecompressMemoryInfoEXT const *>( this );
    }

    operator VkDecompressMemoryInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDecompressMemoryInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::
      tuple<StructureType const &, void const * const &, MemoryDecompressionMethodFlagsEXT const &, uint32_t const &, DecompressMemoryRegionEXT const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, decompressionMethod, regionCount, pRegions );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DecompressMemoryInfoEXT const & ) const = default;
#else
    bool operator==( DecompressMemoryInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decompressionMethod == rhs.decompressionMethod ) && ( regionCount == rhs.regionCount ) &&
             ( pRegions == rhs.pRegions );
#  endif
    }

    bool operator!=( DecompressMemoryInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                     sType               = StructureType::eDecompressMemoryInfoEXT;
    void const *                      pNext               = {};
    MemoryDecompressionMethodFlagsEXT decompressionMethod = {};
    uint32_t                          regionCount         = {};
    DecompressMemoryRegionEXT const * pRegions            = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDecompressMemoryInfoEXT>
  {
    using Type = DecompressMemoryInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDecompressMemoryInfoEXT>
  {
    using Type = DecompressMemoryInfoEXT;
  };

  // wrapper struct for struct VkDecompressMemoryRegionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDecompressMemoryRegionNV.html
  struct DecompressMemoryRegionNV
  {
    using NativeType = VkDecompressMemoryRegionNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DecompressMemoryRegionNV( DeviceAddress                     srcAddress_          = {},
                                                   DeviceAddress                     dstAddress_          = {},
                                                   DeviceSize                        compressedSize_      = {},
                                                   DeviceSize                        decompressedSize_    = {},
                                                   MemoryDecompressionMethodFlagsEXT decompressionMethod_ = {} ) VULKAN_HPP_NOEXCEPT
      : srcAddress{ srcAddress_ }
      , dstAddress{ dstAddress_ }
      , compressedSize{ compressedSize_ }
      , decompressedSize{ decompressedSize_ }
      , decompressionMethod{ decompressionMethod_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DecompressMemoryRegionNV( DecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DecompressMemoryRegionNV( VkDecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : DecompressMemoryRegionNV( *reinterpret_cast<DecompressMemoryRegionNV const *>( &rhs ) )
    {
    }

    DecompressMemoryRegionNV & operator=( DecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DecompressMemoryRegionNV & operator=( VkDecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DecompressMemoryRegionNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcAddress = srcAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcAddress = srcAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setDstAddress( DeviceAddress dstAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstAddress = dstAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setDstAddress( DeviceAddress dstAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstAddress = dstAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setCompressedSize( DeviceSize compressedSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      compressedSize = compressedSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setCompressedSize( DeviceSize compressedSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      compressedSize = compressedSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setDecompressedSize( DeviceSize decompressedSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      decompressedSize = decompressedSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setDecompressedSize( DeviceSize decompressedSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      decompressedSize = decompressedSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setDecompressionMethod( MemoryDecompressionMethodFlagsEXT decompressionMethod_ ) & VULKAN_HPP_NOEXCEPT
    {
      decompressionMethod = decompressionMethod_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setDecompressionMethod( MemoryDecompressionMethodFlagsEXT decompressionMethod_ ) && VULKAN_HPP_NOEXCEPT
    {
      decompressionMethod = decompressionMethod_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDecompressMemoryRegionNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDecompressMemoryRegionNV const *>( this );
    }

    operator VkDecompressMemoryRegionNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDecompressMemoryRegionNV *>( this );
    }

    operator VkDecompressMemoryRegionNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDecompressMemoryRegionNV const *>( this );
    }

    operator VkDecompressMemoryRegionNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDecompressMemoryRegionNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DeviceAddress const &, DeviceAddress const &, DeviceSize const &, DeviceSize const &, MemoryDecompressionMethodFlagsEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( srcAddress, dstAddress, compressedSize, decompressedSize, decompressionMethod );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DecompressMemoryRegionNV const & ) const = default;
#else
    bool operator==( DecompressMemoryRegionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( srcAddress == rhs.srcAddress ) && ( dstAddress == rhs.dstAddress ) && ( compressedSize == rhs.compressedSize ) &&
             ( decompressedSize == rhs.decompressedSize ) && ( decompressionMethod == rhs.decompressionMethod );
#  endif
    }

    bool operator!=( DecompressMemoryRegionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DeviceAddress                     srcAddress          = {};
    DeviceAddress                     dstAddress          = {};
    DeviceSize                        compressedSize      = {};
    DeviceSize                        decompressedSize    = {};
    MemoryDecompressionMethodFlagsEXT decompressionMethod = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDecompressMemoryRegionNV>
  {
    using Type = DecompressMemoryRegionNV;
  };
#endif

  // wrapper struct for struct VkDedicatedAllocationBufferCreateInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDedicatedAllocationBufferCreateInfoNV.html
  struct DedicatedAllocationBufferCreateInfoNV
  {
    using NativeType = VkDedicatedAllocationBufferCreateInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDedicatedAllocationBufferCreateInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , dedicatedAllocation{ dedicatedAllocation_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : DedicatedAllocationBufferCreateInfoNV( *reinterpret_cast<DedicatedAllocationBufferCreateInfoNV const *>( &rhs ) )
    {
    }

    DedicatedAllocationBufferCreateInfoNV & operator=( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DedicatedAllocationBufferCreateInfoNV & operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DedicatedAllocationBufferCreateInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ ) & VULKAN_HPP_NOEXCEPT
    {
      dedicatedAllocation = dedicatedAllocation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV && setDedicatedAllocation( Bool32 dedicatedAllocation_ ) && VULKAN_HPP_NOEXCEPT
    {
      dedicatedAllocation = dedicatedAllocation_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV const *>( this );
    }

    operator VkDedicatedAllocationBufferCreateInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV *>( this );
    }

    operator VkDedicatedAllocationBufferCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV const *>( this );
    }

    operator VkDedicatedAllocationBufferCreateInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, dedicatedAllocation );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DedicatedAllocationBufferCreateInfoNV const & ) const = default;
#else
    bool operator==( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
#  endif
    }

    bool operator!=( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType               = StructureType::eDedicatedAllocationBufferCreateInfoNV;
    void const *  pNext               = {};
    Bool32        dedicatedAllocation = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDedicatedAllocationBufferCreateInfoNV>
  {
    using Type = DedicatedAllocationBufferCreateInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDedicatedAllocationBufferCreateInfoNV>
  {
    using Type = DedicatedAllocationBufferCreateInfoNV;
  };

  // wrapper struct for struct VkDedicatedAllocationImageCreateInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDedicatedAllocationImageCreateInfoNV.html
  struct DedicatedAllocationImageCreateInfoNV
  {
    using NativeType = VkDedicatedAllocationImageCreateInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDedicatedAllocationImageCreateInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , dedicatedAllocation{ dedicatedAllocation_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : DedicatedAllocationImageCreateInfoNV( *reinterpret_cast<DedicatedAllocationImageCreateInfoNV const *>( &rhs ) )
    {
    }

    DedicatedAllocationImageCreateInfoNV & operator=( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DedicatedAllocationImageCreateInfoNV & operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DedicatedAllocationImageCreateInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ ) & VULKAN_HPP_NOEXCEPT
    {
      dedicatedAllocation = dedicatedAllocation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV && setDedicatedAllocation( Bool32 dedicatedAllocation_ ) && VULKAN_HPP_NOEXCEPT
    {
      dedicatedAllocation = dedicatedAllocation_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV const *>( this );
    }

    operator VkDedicatedAllocationImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV *>( this );
    }

    operator VkDedicatedAllocationImageCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV const *>( this );
    }

    operator VkDedicatedAllocationImageCreateInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, dedicatedAllocation );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DedicatedAllocationImageCreateInfoNV const & ) const = default;
#else
    bool operator==( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
#  endif
    }

    bool operator!=( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType               = StructureType::eDedicatedAllocationImageCreateInfoNV;
    void const *  pNext               = {};
    Bool32        dedicatedAllocation = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDedicatedAllocationImageCreateInfoNV>
  {
    using Type = DedicatedAllocationImageCreateInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDedicatedAllocationImageCreateInfoNV>
  {
    using Type = DedicatedAllocationImageCreateInfoNV;
  };

  // wrapper struct for struct VkDedicatedAllocationMemoryAllocateInfoNV, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html
  struct DedicatedAllocationMemoryAllocateInfoNV
  {
    using NativeType = VkDedicatedAllocationMemoryAllocateInfoNV;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( Image image_ = {}, Buffer buffer_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , image{ image_ }
      , buffer{ buffer_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
      : DedicatedAllocationMemoryAllocateInfoNV( *reinterpret_cast<DedicatedAllocationMemoryAllocateInfoNV const *>( &rhs ) )
    {
    }

    DedicatedAllocationMemoryAllocateInfoNV & operator=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DedicatedAllocationMemoryAllocateInfoNV & operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DedicatedAllocationMemoryAllocateInfoNV const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV const *>( this );
    }

    operator VkDedicatedAllocationMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV *>( this );
    }

    operator VkDedicatedAllocationMemoryAllocateInfoNV const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV const *>( this );
    }

    operator VkDedicatedAllocationMemoryAllocateInfoNV *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Image const &, Buffer const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, image, buffer );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const & ) const = default;
#else
    bool operator==( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer );
#  endif
    }

    bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType  = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
    void const *  pNext  = {};
    Image         image  = {};
    Buffer        buffer = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDedicatedAllocationMemoryAllocateInfoNV>
  {
    using Type = DedicatedAllocationMemoryAllocateInfoNV;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDedicatedAllocationMemoryAllocateInfoNV>
  {
    using Type = DedicatedAllocationMemoryAllocateInfoNV;
  };

  // wrapper struct for struct VkMemoryBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryBarrier2.html
  struct MemoryBarrier2
  {
    using NativeType = VkMemoryBarrier2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eMemoryBarrier2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR MemoryBarrier2( PipelineStageFlags2 srcStageMask_  = {},
                                         AccessFlags2        srcAccessMask_ = {},
                                         PipelineStageFlags2 dstStageMask_  = {},
                                         AccessFlags2        dstAccessMask_ = {},
                                         void const *        pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcStageMask{ srcStageMask_ }
      , srcAccessMask{ srcAccessMask_ }
      , dstStageMask{ dstStageMask_ }
      , dstAccessMask{ dstAccessMask_ }
    {
    }

    VULKAN_HPP_CONSTEXPR MemoryBarrier2( MemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    MemoryBarrier2( VkMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryBarrier2( *reinterpret_cast<MemoryBarrier2 const *>( &rhs ) ) {}

    MemoryBarrier2 & operator=( MemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    MemoryBarrier2 & operator=( VkMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<MemoryBarrier2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcStageMask = srcStageMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcStageMask = srcStageMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcAccessMask = srcAccessMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcAccessMask = srcAccessMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstStageMask = dstStageMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstStageMask = dstStageMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstAccessMask = dstAccessMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstAccessMask = dstAccessMask_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkMemoryBarrier2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkMemoryBarrier2 const *>( this );
    }

    operator VkMemoryBarrier2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkMemoryBarrier2 *>( this );
    }

    operator VkMemoryBarrier2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkMemoryBarrier2 const *>( this );
    }

    operator VkMemoryBarrier2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkMemoryBarrier2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::
      tuple<StructureType const &, void const * const &, PipelineStageFlags2 const &, AccessFlags2 const &, PipelineStageFlags2 const &, AccessFlags2 const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( MemoryBarrier2 const & ) const = default;
#else
    bool operator==( MemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) &&
             ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask );
#  endif
    }

    bool operator!=( MemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType       sType         = StructureType::eMemoryBarrier2;
    void const *        pNext         = {};
    PipelineStageFlags2 srcStageMask  = {};
    AccessFlags2        srcAccessMask = {};
    PipelineStageFlags2 dstStageMask  = {};
    AccessFlags2        dstAccessMask = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkMemoryBarrier2>
  {
    using Type = MemoryBarrier2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eMemoryBarrier2>
  {
    using Type = MemoryBarrier2;
  };

  using MemoryBarrier2KHR = MemoryBarrier2;

  // wrapper struct for struct VkImageSubresourceRange, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresourceRange.html
  struct ImageSubresourceRange
  {
    using NativeType = VkImageSubresourceRange;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ImageSubresourceRange( ImageAspectFlags aspectMask_     = {},
                                                uint32_t         baseMipLevel_   = {},
                                                uint32_t         levelCount_     = {},
                                                uint32_t         baseArrayLayer_ = {},
                                                uint32_t         layerCount_     = {} ) VULKAN_HPP_NOEXCEPT
      : aspectMask{ aspectMask_ }
      , baseMipLevel{ baseMipLevel_ }
      , levelCount{ levelCount_ }
      , baseArrayLayer{ baseArrayLayer_ }
      , layerCount{ layerCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ImageSubresourceRange( ImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ImageSubresourceRange( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
      : ImageSubresourceRange( *reinterpret_cast<ImageSubresourceRange const *>( &rhs ) )
    {
    }

    ImageSubresourceRange & operator=( ImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ImageSubresourceRange & operator=( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ImageSubresourceRange const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      aspectMask = aspectMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setBaseMipLevel( uint32_t baseMipLevel_ ) & VULKAN_HPP_NOEXCEPT
    {
      baseMipLevel = baseMipLevel_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setBaseMipLevel( uint32_t baseMipLevel_ ) && VULKAN_HPP_NOEXCEPT
    {
      baseMipLevel = baseMipLevel_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setLevelCount( uint32_t levelCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      levelCount = levelCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setLevelCount( uint32_t levelCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      levelCount = levelCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT
    {
      baseArrayLayer = baseArrayLayer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT
    {
      baseArrayLayer = baseArrayLayer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      layerCount = layerCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      layerCount = layerCount_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageSubresourceRange const *>( this );
    }

    operator VkImageSubresourceRange &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageSubresourceRange *>( this );
    }

    operator VkImageSubresourceRange const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageSubresourceRange const *>( this );
    }

    operator VkImageSubresourceRange *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageSubresourceRange *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<ImageAspectFlags const &, uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( aspectMask, baseMipLevel, levelCount, baseArrayLayer, layerCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ImageSubresourceRange const & ) const = default;
#else
    bool operator==( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( aspectMask == rhs.aspectMask ) && ( baseMipLevel == rhs.baseMipLevel ) && ( levelCount == rhs.levelCount ) &&
             ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount );
#  endif
    }

    bool operator!=( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    ImageAspectFlags aspectMask     = {};
    uint32_t         baseMipLevel   = {};
    uint32_t         levelCount     = {};
    uint32_t         baseArrayLayer = {};
    uint32_t         layerCount     = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkImageSubresourceRange>
  {
    using Type = ImageSubresourceRange;
  };
#endif

  // wrapper struct for struct VkImageMemoryBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageMemoryBarrier2.html
  struct ImageMemoryBarrier2
  {
    using NativeType = VkImageMemoryBarrier2;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eImageMemoryBarrier2;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR ImageMemoryBarrier2( PipelineStageFlags2   srcStageMask_        = {},
                                              AccessFlags2          srcAccessMask_       = {},
                                              PipelineStageFlags2   dstStageMask_        = {},
                                              AccessFlags2          dstAccessMask_       = {},
                                              ImageLayout           oldLayout_           = ImageLayout::eUndefined,
                                              ImageLayout           newLayout_           = ImageLayout::eUndefined,
                                              uint32_t              srcQueueFamilyIndex_ = {},
                                              uint32_t              dstQueueFamilyIndex_ = {},
                                              Image                 image_               = {},
                                              ImageSubresourceRange subresourceRange_    = {},
                                              void const *          pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , srcStageMask{ srcStageMask_ }
      , srcAccessMask{ srcAccessMask_ }
      , dstStageMask{ dstStageMask_ }
      , dstAccessMask{ dstAccessMask_ }
      , oldLayout{ oldLayout_ }
      , newLayout{ newLayout_ }
      , srcQueueFamilyIndex{ srcQueueFamilyIndex_ }
      , dstQueueFamilyIndex{ dstQueueFamilyIndex_ }
      , image{ image_ }
      , subresourceRange{ subresourceRange_ }
    {
    }

    VULKAN_HPP_CONSTEXPR ImageMemoryBarrier2( ImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    ImageMemoryBarrier2( VkImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageMemoryBarrier2( *reinterpret_cast<ImageMemoryBarrier2 const *>( &rhs ) )
    {
    }

    ImageMemoryBarrier2 & operator=( ImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    ImageMemoryBarrier2 & operator=( VkImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<ImageMemoryBarrier2 const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcStageMask = srcStageMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcStageMask = srcStageMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcAccessMask = srcAccessMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcAccessMask = srcAccessMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstStageMask = dstStageMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstStageMask = dstStageMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstAccessMask = dstAccessMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstAccessMask = dstAccessMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setOldLayout( ImageLayout oldLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      oldLayout = oldLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setOldLayout( ImageLayout oldLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      oldLayout = oldLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setNewLayout( ImageLayout newLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      newLayout = newLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setNewLayout( ImageLayout newLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      newLayout = newLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      srcQueueFamilyIndex = srcQueueFamilyIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      srcQueueFamilyIndex = srcQueueFamilyIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstQueueFamilyIndex = dstQueueFamilyIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstQueueFamilyIndex = dstQueueFamilyIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT
    {
      image = image_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) & VULKAN_HPP_NOEXCEPT
    {
      subresourceRange = subresourceRange_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) && VULKAN_HPP_NOEXCEPT
    {
      subresourceRange = subresourceRange_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkImageMemoryBarrier2 const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageMemoryBarrier2 const *>( this );
    }

    operator VkImageMemoryBarrier2 &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkImageMemoryBarrier2 *>( this );
    }

    operator VkImageMemoryBarrier2 const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageMemoryBarrier2 const *>( this );
    }

    operator VkImageMemoryBarrier2 *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkImageMemoryBarrier2 *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               PipelineStageFlags2 const &,
               AccessFlags2 const &,
               PipelineStageFlags2 const &,
               AccessFlags2 const &,
               ImageLayout const &,
               ImageLayout const &,
               uint32_t const &,
               uint32_t const &,
               Image const &,
               ImageSubresourceRange const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       srcStageMask,
                       srcAccessMask,
                       dstStageMask,
                       dstAccessMask,
                       oldLayout,
                       newLayout,
                       srcQueueFamilyIndex,
                       dstQueueFamilyIndex,
                       image,
                       subresourceRange );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( ImageMemoryBarrier2 const & ) const = default;
#else
    bool operator==( ImageMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) &&
             ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) &&
             ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) &&
             ( image == rhs.image ) && ( subresourceRange == rhs.subresourceRange );
#  endif
    }

    bool operator!=( ImageMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType         sType               = StructureType::eImageMemoryBarrier2;
    void const *          pNext               = {};
    PipelineStageFlags2   srcStageMask        = {};
    AccessFlags2          srcAccessMask       = {};
    PipelineStageFlags2   dstStageMask        = {};
    AccessFlags2          dstAccessMask       = {};
    ImageLayout           oldLayout           = ImageLayout::eUndefined;
    ImageLayout           newLayout           = ImageLayout::eUndefined;
    uint32_t              srcQueueFamilyIndex = {};
    uint32_t              dstQueueFamilyIndex = {};
    Image                 image               = {};
    ImageSubresourceRange subresourceRange    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkImageMemoryBarrier2>
  {
    using Type = ImageMemoryBarrier2;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eImageMemoryBarrier2>
  {
    using Type = ImageMemoryBarrier2;
  };

  using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;

  // wrapper struct for struct VkDependencyInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyInfo.html
  struct DependencyInfo
  {
    using NativeType = VkDependencyInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDependencyInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DependencyInfo( DependencyFlags              dependencyFlags_          = {},
                                         uint32_t                     memoryBarrierCount_       = {},
                                         MemoryBarrier2 const *       pMemoryBarriers_          = {},
                                         uint32_t                     bufferMemoryBarrierCount_ = {},
                                         BufferMemoryBarrier2 const * pBufferMemoryBarriers_    = {},
                                         uint32_t                     imageMemoryBarrierCount_  = {},
                                         ImageMemoryBarrier2 const *  pImageMemoryBarriers_     = {},
                                         void const *                 pNext_                    = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , dependencyFlags{ dependencyFlags_ }
      , memoryBarrierCount{ memoryBarrierCount_ }
      , pMemoryBarriers{ pMemoryBarriers_ }
      , bufferMemoryBarrierCount{ bufferMemoryBarrierCount_ }
      , pBufferMemoryBarriers{ pBufferMemoryBarriers_ }
      , imageMemoryBarrierCount{ imageMemoryBarrierCount_ }
      , pImageMemoryBarriers{ pImageMemoryBarriers_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DependencyInfo( DependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DependencyInfo( VkDependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DependencyInfo( *reinterpret_cast<DependencyInfo const *>( &rhs ) ) {}

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DependencyInfo( DependencyFlags                                             dependencyFlags_,
                    ArrayProxyNoTemporaries<MemoryBarrier2 const> const &       memoryBarriers_,
                    ArrayProxyNoTemporaries<BufferMemoryBarrier2 const> const & bufferMemoryBarriers_ = {},
                    ArrayProxyNoTemporaries<ImageMemoryBarrier2 const> const &  imageMemoryBarriers_  = {},
                    void const *                                                pNext_                = nullptr )
      : pNext( pNext_ )
      , dependencyFlags( dependencyFlags_ )
      , memoryBarrierCount( static_cast<uint32_t>( memoryBarriers_.size() ) )
      , pMemoryBarriers( memoryBarriers_.data() )
      , bufferMemoryBarrierCount( static_cast<uint32_t>( bufferMemoryBarriers_.size() ) )
      , pBufferMemoryBarriers( bufferMemoryBarriers_.data() )
      , imageMemoryBarrierCount( static_cast<uint32_t>( imageMemoryBarriers_.size() ) )
      , pImageMemoryBarriers( imageMemoryBarriers_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DependencyInfo & operator=( DependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DependencyInfo & operator=( VkDependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DependencyInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setDependencyFlags( DependencyFlags dependencyFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      dependencyFlags = dependencyFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setDependencyFlags( DependencyFlags dependencyFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      dependencyFlags = dependencyFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setMemoryBarrierCount( uint32_t memoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      memoryBarrierCount = memoryBarrierCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setMemoryBarrierCount( uint32_t memoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      memoryBarrierCount = memoryBarrierCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPMemoryBarriers( MemoryBarrier2 const * pMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT
    {
      pMemoryBarriers = pMemoryBarriers_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPMemoryBarriers( MemoryBarrier2 const * pMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT
    {
      pMemoryBarriers = pMemoryBarriers_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DependencyInfo & setMemoryBarriers( ArrayProxyNoTemporaries<MemoryBarrier2 const> const & memoryBarriers_ ) VULKAN_HPP_NOEXCEPT
    {
      memoryBarrierCount = static_cast<uint32_t>( memoryBarriers_.size() );
      pMemoryBarriers    = memoryBarriers_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setBufferMemoryBarrierCount( uint32_t bufferMemoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      bufferMemoryBarrierCount = bufferMemoryBarrierCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setBufferMemoryBarrierCount( uint32_t bufferMemoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      bufferMemoryBarrierCount = bufferMemoryBarrierCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPBufferMemoryBarriers( BufferMemoryBarrier2 const * pBufferMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT
    {
      pBufferMemoryBarriers = pBufferMemoryBarriers_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPBufferMemoryBarriers( BufferMemoryBarrier2 const * pBufferMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT
    {
      pBufferMemoryBarriers = pBufferMemoryBarriers_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DependencyInfo & setBufferMemoryBarriers( ArrayProxyNoTemporaries<BufferMemoryBarrier2 const> const & bufferMemoryBarriers_ ) VULKAN_HPP_NOEXCEPT
    {
      bufferMemoryBarrierCount = static_cast<uint32_t>( bufferMemoryBarriers_.size() );
      pBufferMemoryBarriers    = bufferMemoryBarriers_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setImageMemoryBarrierCount( uint32_t imageMemoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageMemoryBarrierCount = imageMemoryBarrierCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setImageMemoryBarrierCount( uint32_t imageMemoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageMemoryBarrierCount = imageMemoryBarrierCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPImageMemoryBarriers( ImageMemoryBarrier2 const * pImageMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT
    {
      pImageMemoryBarriers = pImageMemoryBarriers_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPImageMemoryBarriers( ImageMemoryBarrier2 const * pImageMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT
    {
      pImageMemoryBarriers = pImageMemoryBarriers_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DependencyInfo & setImageMemoryBarriers( ArrayProxyNoTemporaries<ImageMemoryBarrier2 const> const & imageMemoryBarriers_ ) VULKAN_HPP_NOEXCEPT
    {
      imageMemoryBarrierCount = static_cast<uint32_t>( imageMemoryBarriers_.size() );
      pImageMemoryBarriers    = imageMemoryBarriers_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDependencyInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDependencyInfo const *>( this );
    }

    operator VkDependencyInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDependencyInfo *>( this );
    }

    operator VkDependencyInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDependencyInfo const *>( this );
    }

    operator VkDependencyInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDependencyInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DependencyFlags const &,
               uint32_t const &,
               MemoryBarrier2 const * const &,
               uint32_t const &,
               BufferMemoryBarrier2 const * const &,
               uint32_t const &,
               ImageMemoryBarrier2 const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       dependencyFlags,
                       memoryBarrierCount,
                       pMemoryBarriers,
                       bufferMemoryBarrierCount,
                       pBufferMemoryBarriers,
                       imageMemoryBarrierCount,
                       pImageMemoryBarriers );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DependencyInfo const & ) const = default;
#else
    bool operator==( DependencyInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dependencyFlags == rhs.dependencyFlags ) &&
             ( memoryBarrierCount == rhs.memoryBarrierCount ) && ( pMemoryBarriers == rhs.pMemoryBarriers ) &&
             ( bufferMemoryBarrierCount == rhs.bufferMemoryBarrierCount ) && ( pBufferMemoryBarriers == rhs.pBufferMemoryBarriers ) &&
             ( imageMemoryBarrierCount == rhs.imageMemoryBarrierCount ) && ( pImageMemoryBarriers == rhs.pImageMemoryBarriers );
#  endif
    }

    bool operator!=( DependencyInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                sType                    = StructureType::eDependencyInfo;
    void const *                 pNext                    = {};
    DependencyFlags              dependencyFlags          = {};
    uint32_t                     memoryBarrierCount       = {};
    MemoryBarrier2 const *       pMemoryBarriers          = {};
    uint32_t                     bufferMemoryBarrierCount = {};
    BufferMemoryBarrier2 const * pBufferMemoryBarriers    = {};
    uint32_t                     imageMemoryBarrierCount  = {};
    ImageMemoryBarrier2 const *  pImageMemoryBarriers     = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDependencyInfo>
  {
    using Type = DependencyInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDependencyInfo>
  {
    using Type = DependencyInfo;
  };

  using DependencyInfoKHR = DependencyInfo;

  // wrapper struct for struct VkDepthBiasInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthBiasInfoEXT.html
  struct DepthBiasInfoEXT
  {
    using NativeType = VkDepthBiasInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDepthBiasInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DepthBiasInfoEXT( float        depthBiasConstantFactor_ = {},
                                           float        depthBiasClamp_          = {},
                                           float        depthBiasSlopeFactor_    = {},
                                           void const * pNext_                   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , depthBiasConstantFactor{ depthBiasConstantFactor_ }
      , depthBiasClamp{ depthBiasClamp_ }
      , depthBiasSlopeFactor{ depthBiasSlopeFactor_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DepthBiasInfoEXT( DepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DepthBiasInfoEXT( VkDepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DepthBiasInfoEXT( *reinterpret_cast<DepthBiasInfoEXT const *>( &rhs ) ) {}

    DepthBiasInfoEXT & operator=( DepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DepthBiasInfoEXT & operator=( VkDepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DepthBiasInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthBiasConstantFactor = depthBiasConstantFactor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthBiasConstantFactor = depthBiasConstantFactor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setDepthBiasClamp( float depthBiasClamp_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthBiasClamp = depthBiasClamp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setDepthBiasClamp( float depthBiasClamp_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthBiasClamp = depthBiasClamp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthBiasSlopeFactor = depthBiasSlopeFactor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthBiasSlopeFactor = depthBiasSlopeFactor_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDepthBiasInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDepthBiasInfoEXT const *>( this );
    }

    operator VkDepthBiasInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDepthBiasInfoEXT *>( this );
    }

    operator VkDepthBiasInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDepthBiasInfoEXT const *>( this );
    }

    operator VkDepthBiasInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDepthBiasInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, float const &, float const &, float const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DepthBiasInfoEXT const & ) const = default;
#else
    bool operator==( DepthBiasInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) &&
             ( depthBiasClamp == rhs.depthBiasClamp ) && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor );
#  endif
    }

    bool operator!=( DepthBiasInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                   = StructureType::eDepthBiasInfoEXT;
    void const *  pNext                   = {};
    float         depthBiasConstantFactor = {};
    float         depthBiasClamp          = {};
    float         depthBiasSlopeFactor    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDepthBiasInfoEXT>
  {
    using Type = DepthBiasInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDepthBiasInfoEXT>
  {
    using Type = DepthBiasInfoEXT;
  };

  // wrapper struct for struct VkDepthBiasRepresentationInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthBiasRepresentationInfoEXT.html
  struct DepthBiasRepresentationInfoEXT
  {
    using NativeType = VkDepthBiasRepresentationInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDepthBiasRepresentationInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      DepthBiasRepresentationInfoEXT( DepthBiasRepresentationEXT depthBiasRepresentation_ = DepthBiasRepresentationEXT::eLeastRepresentableValueFormat,
                                      Bool32                     depthBiasExact_          = {},
                                      void const *               pNext_                   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , depthBiasRepresentation{ depthBiasRepresentation_ }
      , depthBiasExact{ depthBiasExact_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DepthBiasRepresentationInfoEXT( DepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DepthBiasRepresentationInfoEXT( VkDepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DepthBiasRepresentationInfoEXT( *reinterpret_cast<DepthBiasRepresentationInfoEXT const *>( &rhs ) )
    {
    }

    DepthBiasRepresentationInfoEXT & operator=( DepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DepthBiasRepresentationInfoEXT & operator=( VkDepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DepthBiasRepresentationInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT & setDepthBiasRepresentation( DepthBiasRepresentationEXT depthBiasRepresentation_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      depthBiasRepresentation = depthBiasRepresentation_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT && setDepthBiasRepresentation( DepthBiasRepresentationEXT depthBiasRepresentation_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      depthBiasRepresentation = depthBiasRepresentation_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT & setDepthBiasExact( Bool32 depthBiasExact_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthBiasExact = depthBiasExact_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT && setDepthBiasExact( Bool32 depthBiasExact_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthBiasExact = depthBiasExact_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDepthBiasRepresentationInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDepthBiasRepresentationInfoEXT const *>( this );
    }

    operator VkDepthBiasRepresentationInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDepthBiasRepresentationInfoEXT *>( this );
    }

    operator VkDepthBiasRepresentationInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDepthBiasRepresentationInfoEXT const *>( this );
    }

    operator VkDepthBiasRepresentationInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDepthBiasRepresentationInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DepthBiasRepresentationEXT const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, depthBiasRepresentation, depthBiasExact );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DepthBiasRepresentationInfoEXT const & ) const = default;
#else
    bool operator==( DepthBiasRepresentationInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasRepresentation == rhs.depthBiasRepresentation ) &&
             ( depthBiasExact == rhs.depthBiasExact );
#  endif
    }

    bool operator!=( DepthBiasRepresentationInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType              sType                   = StructureType::eDepthBiasRepresentationInfoEXT;
    void const *               pNext                   = {};
    DepthBiasRepresentationEXT depthBiasRepresentation = DepthBiasRepresentationEXT::eLeastRepresentableValueFormat;
    Bool32                     depthBiasExact          = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDepthBiasRepresentationInfoEXT>
  {
    using Type = DepthBiasRepresentationInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDepthBiasRepresentationInfoEXT>
  {
    using Type = DepthBiasRepresentationInfoEXT;
  };

  // wrapper struct for struct VkDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthClampRangeEXT.html
  struct DepthClampRangeEXT
  {
    using NativeType = VkDepthClampRangeEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DepthClampRangeEXT( float minDepthClamp_ = {}, float maxDepthClamp_ = {} ) VULKAN_HPP_NOEXCEPT
      : minDepthClamp{ minDepthClamp_ }
      , maxDepthClamp{ maxDepthClamp_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DepthClampRangeEXT( DepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DepthClampRangeEXT( VkDepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DepthClampRangeEXT( *reinterpret_cast<DepthClampRangeEXT const *>( &rhs ) ) {}

    DepthClampRangeEXT & operator=( DepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DepthClampRangeEXT & operator=( VkDepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DepthClampRangeEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT & setMinDepthClamp( float minDepthClamp_ ) & VULKAN_HPP_NOEXCEPT
    {
      minDepthClamp = minDepthClamp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT && setMinDepthClamp( float minDepthClamp_ ) && VULKAN_HPP_NOEXCEPT
    {
      minDepthClamp = minDepthClamp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT & setMaxDepthClamp( float maxDepthClamp_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxDepthClamp = maxDepthClamp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT && setMaxDepthClamp( float maxDepthClamp_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxDepthClamp = maxDepthClamp_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDepthClampRangeEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDepthClampRangeEXT const *>( this );
    }

    operator VkDepthClampRangeEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDepthClampRangeEXT *>( this );
    }

    operator VkDepthClampRangeEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDepthClampRangeEXT const *>( this );
    }

    operator VkDepthClampRangeEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDepthClampRangeEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<float const &, float const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( minDepthClamp, maxDepthClamp );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DepthClampRangeEXT const & ) const = default;
#else
    bool operator==( DepthClampRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( minDepthClamp == rhs.minDepthClamp ) && ( maxDepthClamp == rhs.maxDepthClamp );
#  endif
    }

    bool operator!=( DepthClampRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    float minDepthClamp = {};
    float maxDepthClamp = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDepthClampRangeEXT>
  {
    using Type = DepthClampRangeEXT;
  };
#endif

  // wrapper struct for struct VkDescriptorAddressInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorAddressInfoEXT.html
  struct DescriptorAddressInfoEXT
  {
    using NativeType = VkDescriptorAddressInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorAddressInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorAddressInfoEXT( DeviceAddress address_ = {},
                                                   DeviceSize    range_   = {},
                                                   Format        format_  = Format::eUndefined,
                                                   void *        pNext_   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , address{ address_ }
      , range{ range_ }
      , format{ format_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorAddressInfoEXT( DescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorAddressInfoEXT( VkDescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorAddressInfoEXT( *reinterpret_cast<DescriptorAddressInfoEXT const *>( &rhs ) )
    {
    }

    DescriptorAddressInfoEXT & operator=( DescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorAddressInfoEXT & operator=( VkDescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorAddressInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT
    {
      address = address_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT
    {
      address = address_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setRange( DeviceSize range_ ) & VULKAN_HPP_NOEXCEPT
    {
      range = range_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setRange( DeviceSize range_ ) && VULKAN_HPP_NOEXCEPT
    {
      range = range_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT
    {
      format = format_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorAddressInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorAddressInfoEXT const *>( this );
    }

    operator VkDescriptorAddressInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorAddressInfoEXT *>( this );
    }

    operator VkDescriptorAddressInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorAddressInfoEXT const *>( this );
    }

    operator VkDescriptorAddressInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorAddressInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, DeviceAddress const &, DeviceSize const &, Format const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, address, range, format );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorAddressInfoEXT const & ) const = default;
#else
    bool operator==( DescriptorAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( address == rhs.address ) && ( range == rhs.range ) && ( format == rhs.format );
#  endif
    }

    bool operator!=( DescriptorAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType   = StructureType::eDescriptorAddressInfoEXT;
    void *        pNext   = {};
    DeviceAddress address = {};
    DeviceSize    range   = {};
    Format        format  = Format::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorAddressInfoEXT>
  {
    using Type = DescriptorAddressInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorAddressInfoEXT>
  {
    using Type = DescriptorAddressInfoEXT;
  };

  // wrapper struct for struct VkDescriptorBufferBindingInfoEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBufferBindingInfoEXT.html
  struct DescriptorBufferBindingInfoEXT
  {
    using NativeType = VkDescriptorBufferBindingInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorBufferBindingInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      DescriptorBufferBindingInfoEXT( DeviceAddress address_ = {}, BufferUsageFlags usage_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , address{ address_ }
      , usage{ usage_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorBufferBindingInfoEXT( DescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorBufferBindingInfoEXT( VkDescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorBufferBindingInfoEXT( *reinterpret_cast<DescriptorBufferBindingInfoEXT const *>( &rhs ) )
    {
    }

    DescriptorBufferBindingInfoEXT & operator=( DescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorBufferBindingInfoEXT & operator=( VkDescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorBufferBindingInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT
    {
      address = address_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT
    {
      address = address_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT & setUsage( BufferUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT
    {
      usage = usage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT && setUsage( BufferUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT
    {
      usage = usage_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorBufferBindingInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorBufferBindingInfoEXT const *>( this );
    }

    operator VkDescriptorBufferBindingInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorBufferBindingInfoEXT *>( this );
    }

    operator VkDescriptorBufferBindingInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorBufferBindingInfoEXT const *>( this );
    }

    operator VkDescriptorBufferBindingInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorBufferBindingInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceAddress const &, BufferUsageFlags const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, address, usage );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorBufferBindingInfoEXT const & ) const = default;
#else
    bool operator==( DescriptorBufferBindingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( address == rhs.address ) && ( usage == rhs.usage );
#  endif
    }

    bool operator!=( DescriptorBufferBindingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType   = StructureType::eDescriptorBufferBindingInfoEXT;
    void const *     pNext   = {};
    DeviceAddress    address = {};
    BufferUsageFlags usage   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorBufferBindingInfoEXT>
  {
    using Type = DescriptorBufferBindingInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorBufferBindingInfoEXT>
  {
    using Type = DescriptorBufferBindingInfoEXT;
  };

  // wrapper struct for struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.html
  struct DescriptorBufferBindingPushDescriptorBufferHandleEXT
  {
    using NativeType = VkDescriptorBufferBindingPushDescriptorBufferHandleEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorBufferBindingPushDescriptorBufferHandleEXT( Buffer buffer_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , buffer{ buffer_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      DescriptorBufferBindingPushDescriptorBufferHandleEXT( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorBufferBindingPushDescriptorBufferHandleEXT( VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorBufferBindingPushDescriptorBufferHandleEXT( *reinterpret_cast<DescriptorBufferBindingPushDescriptorBufferHandleEXT const *>( &rhs ) )
    {
    }

    DescriptorBufferBindingPushDescriptorBufferHandleEXT &
      operator=( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorBufferBindingPushDescriptorBufferHandleEXT & operator=( VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorBufferBindingPushDescriptorBufferHandleEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const *>( this );
    }

    operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *>( this );
    }

    operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const *>( this );
    }

    operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, Buffer const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, buffer );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & ) const = default;
#else
    bool operator==( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
#  endif
    }

    bool operator!=( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType  = StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT;
    void const *  pNext  = {};
    Buffer        buffer = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT>
  {
    using Type = DescriptorBufferBindingPushDescriptorBufferHandleEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT>
  {
    using Type = DescriptorBufferBindingPushDescriptorBufferHandleEXT;
  };

  // wrapper struct for struct VkDescriptorBufferInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBufferInfo.html
  struct DescriptorBufferInfo
  {
    using NativeType = VkDescriptorBufferInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( Buffer buffer_ = {}, DeviceSize offset_ = {}, DeviceSize range_ = {} ) VULKAN_HPP_NOEXCEPT
      : buffer{ buffer_ }
      , offset{ offset_ }
      , range{ range_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorBufferInfo( *reinterpret_cast<DescriptorBufferInfo const *>( &rhs ) )
    {
    }

    DescriptorBufferInfo & operator=( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorBufferInfo & operator=( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorBufferInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      buffer = buffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo & setRange( DeviceSize range_ ) & VULKAN_HPP_NOEXCEPT
    {
      range = range_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo && setRange( DeviceSize range_ ) && VULKAN_HPP_NOEXCEPT
    {
      range = range_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorBufferInfo const *>( this );
    }

    operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorBufferInfo *>( this );
    }

    operator VkDescriptorBufferInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorBufferInfo const *>( this );
    }

    operator VkDescriptorBufferInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorBufferInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<Buffer const &, DeviceSize const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( buffer, offset, range );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorBufferInfo const & ) const = default;
#else
    bool operator==( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( range == rhs.range );
#  endif
    }

    bool operator!=( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    Buffer     buffer = {};
    DeviceSize offset = {};
    DeviceSize range  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorBufferInfo>
  {
    using Type = DescriptorBufferInfo;
  };
#endif

  // wrapper struct for struct VkDescriptorImageInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorImageInfo.html
  struct DescriptorImageInfo
  {
    using NativeType = VkDescriptorImageInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      DescriptorImageInfo( Sampler sampler_ = {}, ImageView imageView_ = {}, ImageLayout imageLayout_ = ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT
      : sampler{ sampler_ }
      , imageView{ imageView_ }
      , imageLayout{ imageLayout_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorImageInfo( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DescriptorImageInfo( *reinterpret_cast<DescriptorImageInfo const *>( &rhs ) )
    {
    }

    DescriptorImageInfo & operator=( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorImageInfo & operator=( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorImageInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo & setSampler( Sampler sampler_ ) & VULKAN_HPP_NOEXCEPT
    {
      sampler = sampler_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo && setSampler( Sampler sampler_ ) && VULKAN_HPP_NOEXCEPT
    {
      sampler = sampler_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageView = imageView_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageView = imageView_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageLayout = imageLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageLayout = imageLayout_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorImageInfo const *>( this );
    }

    operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorImageInfo *>( this );
    }

    operator VkDescriptorImageInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorImageInfo const *>( this );
    }

    operator VkDescriptorImageInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorImageInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<Sampler const &, ImageView const &, ImageLayout const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sampler, imageView, imageLayout );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorImageInfo const & ) const = default;
#else
    bool operator==( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sampler == rhs.sampler ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout );
#  endif
    }

    bool operator!=( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    Sampler     sampler     = {};
    ImageView   imageView   = {};
    ImageLayout imageLayout = ImageLayout::eUndefined;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorImageInfo>
  {
    using Type = DescriptorImageInfo;
  };
#endif

  union DescriptorDataEXT
  {
    using NativeType = VkDescriptorDataEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( Sampler const * pSampler_ = {} ) : pSampler( pSampler_ ) {}

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( DescriptorImageInfo const * pDescriptorImageInfo_ ) : pCombinedImageSampler( pDescriptorImageInfo_ ) {}

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( DescriptorAddressInfoEXT const * pDescriptorAddressInfoEXT_ ) : pUniformTexelBuffer( pDescriptorAddressInfoEXT_ )
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( DeviceAddress accelerationStructure_ ) : accelerationStructure( accelerationStructure_ ) {}
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPSampler( Sampler const * pSampler_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSampler = pSampler_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPSampler( Sampler const * pSampler_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSampler = pSampler_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPCombinedImageSampler( DescriptorImageInfo const * pCombinedImageSampler_ ) & VULKAN_HPP_NOEXCEPT
    {
      pCombinedImageSampler = pCombinedImageSampler_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPCombinedImageSampler( DescriptorImageInfo const * pCombinedImageSampler_ ) && VULKAN_HPP_NOEXCEPT
    {
      pCombinedImageSampler = pCombinedImageSampler_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPInputAttachmentImage( DescriptorImageInfo const * pInputAttachmentImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      pInputAttachmentImage = pInputAttachmentImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPInputAttachmentImage( DescriptorImageInfo const * pInputAttachmentImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      pInputAttachmentImage = pInputAttachmentImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPSampledImage( DescriptorImageInfo const * pSampledImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSampledImage = pSampledImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPSampledImage( DescriptorImageInfo const * pSampledImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSampledImage = pSampledImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPStorageImage( DescriptorImageInfo const * pStorageImage_ ) & VULKAN_HPP_NOEXCEPT
    {
      pStorageImage = pStorageImage_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPStorageImage( DescriptorImageInfo const * pStorageImage_ ) && VULKAN_HPP_NOEXCEPT
    {
      pStorageImage = pStorageImage_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPUniformTexelBuffer( DescriptorAddressInfoEXT const * pUniformTexelBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      pUniformTexelBuffer = pUniformTexelBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPUniformTexelBuffer( DescriptorAddressInfoEXT const * pUniformTexelBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      pUniformTexelBuffer = pUniformTexelBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPStorageTexelBuffer( DescriptorAddressInfoEXT const * pStorageTexelBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      pStorageTexelBuffer = pStorageTexelBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPStorageTexelBuffer( DescriptorAddressInfoEXT const * pStorageTexelBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      pStorageTexelBuffer = pStorageTexelBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPUniformBuffer( DescriptorAddressInfoEXT const * pUniformBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      pUniformBuffer = pUniformBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPUniformBuffer( DescriptorAddressInfoEXT const * pUniformBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      pUniformBuffer = pUniformBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPStorageBuffer( DescriptorAddressInfoEXT const * pStorageBuffer_ ) & VULKAN_HPP_NOEXCEPT
    {
      pStorageBuffer = pStorageBuffer_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPStorageBuffer( DescriptorAddressInfoEXT const * pStorageBuffer_ ) && VULKAN_HPP_NOEXCEPT
    {
      pStorageBuffer = pStorageBuffer_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setAccelerationStructure( DeviceAddress accelerationStructure_ ) & VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setAccelerationStructure( DeviceAddress accelerationStructure_ ) && VULKAN_HPP_NOEXCEPT
    {
      accelerationStructure = accelerationStructure_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorDataEXT const &() const
    {
      return *reinterpret_cast<VkDescriptorDataEXT const *>( this );
    }

    operator VkDescriptorDataEXT &()
    {
      return *reinterpret_cast<VkDescriptorDataEXT *>( this );
    }

#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    Sampler const *                  pSampler;
    DescriptorImageInfo const *      pCombinedImageSampler;
    DescriptorImageInfo const *      pInputAttachmentImage;
    DescriptorImageInfo const *      pSampledImage;
    DescriptorImageInfo const *      pStorageImage;
    DescriptorAddressInfoEXT const * pUniformTexelBuffer;
    DescriptorAddressInfoEXT const * pStorageTexelBuffer;
    DescriptorAddressInfoEXT const * pUniformBuffer;
    DescriptorAddressInfoEXT const * pStorageBuffer;
    DeviceAddress                    accelerationStructure;
#else
    VkSampler const *                  pSampler;
    VkDescriptorImageInfo const *      pCombinedImageSampler;
    VkDescriptorImageInfo const *      pInputAttachmentImage;
    VkDescriptorImageInfo const *      pSampledImage;
    VkDescriptorImageInfo const *      pStorageImage;
    VkDescriptorAddressInfoEXT const * pUniformTexelBuffer;
    VkDescriptorAddressInfoEXT const * pStorageTexelBuffer;
    VkDescriptorAddressInfoEXT const * pUniformBuffer;
    VkDescriptorAddressInfoEXT const * pStorageBuffer;
    VkDeviceAddress                    accelerationStructure;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorDataEXT>
  {
    using Type = DescriptorDataEXT;
  };
#endif

  // wrapper struct for struct VkDescriptorGetInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorGetInfoEXT.html
  struct DescriptorGetInfoEXT
  {
    using NativeType = VkDescriptorGetInfoEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorGetInfoEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14
      DescriptorGetInfoEXT( DescriptorType type_ = DescriptorType::eSampler, DescriptorDataEXT data_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , type{ type_ }
      , data{ data_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT( DescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorGetInfoEXT( VkDescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorGetInfoEXT( *reinterpret_cast<DescriptorGetInfoEXT const *>( &rhs ) )
    {
    }

    DescriptorGetInfoEXT & operator=( DescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorGetInfoEXT & operator=( VkDescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorGetInfoEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT & setType( DescriptorType type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT && setType( DescriptorType type_ ) && VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT & setData( DescriptorDataEXT const & data_ ) & VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT && setData( DescriptorDataEXT const & data_ ) && VULKAN_HPP_NOEXCEPT
    {
      data = data_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorGetInfoEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorGetInfoEXT const *>( this );
    }

    operator VkDescriptorGetInfoEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorGetInfoEXT *>( this );
    }

    operator VkDescriptorGetInfoEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorGetInfoEXT const *>( this );
    }

    operator VkDescriptorGetInfoEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorGetInfoEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DescriptorType const &, DescriptorDataEXT const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, type, data );
    }
#endif

  public:
    StructureType     sType = StructureType::eDescriptorGetInfoEXT;
    void const *      pNext = {};
    DescriptorType    type  = DescriptorType::eSampler;
    DescriptorDataEXT data  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorGetInfoEXT>
  {
    using Type = DescriptorGetInfoEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorGetInfoEXT>
  {
    using Type = DescriptorGetInfoEXT;
  };

  // wrapper struct for struct VkDescriptorGetTensorInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorGetTensorInfoARM.html
  struct DescriptorGetTensorInfoARM
  {
    using NativeType = VkDescriptorGetTensorInfoARM;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorGetTensorInfoARM;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorGetTensorInfoARM( TensorViewARM tensorView_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , tensorView{ tensorView_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorGetTensorInfoARM( DescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorGetTensorInfoARM( VkDescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorGetTensorInfoARM( *reinterpret_cast<DescriptorGetTensorInfoARM const *>( &rhs ) )
    {
    }

    DescriptorGetTensorInfoARM & operator=( DescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorGetTensorInfoARM & operator=( VkDescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorGetTensorInfoARM const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM & setTensorView( TensorViewARM tensorView_ ) & VULKAN_HPP_NOEXCEPT
    {
      tensorView = tensorView_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM && setTensorView( TensorViewARM tensorView_ ) && VULKAN_HPP_NOEXCEPT
    {
      tensorView = tensorView_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorGetTensorInfoARM const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorGetTensorInfoARM const *>( this );
    }

    operator VkDescriptorGetTensorInfoARM &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorGetTensorInfoARM *>( this );
    }

    operator VkDescriptorGetTensorInfoARM const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorGetTensorInfoARM const *>( this );
    }

    operator VkDescriptorGetTensorInfoARM *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorGetTensorInfoARM *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, TensorViewARM const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, tensorView );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorGetTensorInfoARM const & ) const = default;
#else
    bool operator==( DescriptorGetTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorView == rhs.tensorView );
#  endif
    }

    bool operator!=( DescriptorGetTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType      = StructureType::eDescriptorGetTensorInfoARM;
    void const *  pNext      = {};
    TensorViewARM tensorView = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorGetTensorInfoARM>
  {
    using Type = DescriptorGetTensorInfoARM;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorGetTensorInfoARM>
  {
    using Type = DescriptorGetTensorInfoARM;
  };

  // wrapper struct for struct VkSamplerCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateInfo.html
  struct SamplerCreateInfo
  {
    using NativeType = VkSamplerCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eSamplerCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR SamplerCreateInfo( SamplerCreateFlags flags_                   = {},
                                            Filter             magFilter_               = Filter::eNearest,
                                            Filter             minFilter_               = Filter::eNearest,
                                            SamplerMipmapMode  mipmapMode_              = SamplerMipmapMode::eNearest,
                                            SamplerAddressMode addressModeU_            = SamplerAddressMode::eRepeat,
                                            SamplerAddressMode addressModeV_            = SamplerAddressMode::eRepeat,
                                            SamplerAddressMode addressModeW_            = SamplerAddressMode::eRepeat,
                                            float              mipLodBias_              = {},
                                            Bool32             anisotropyEnable_        = {},
                                            float              maxAnisotropy_           = {},
                                            Bool32             compareEnable_           = {},
                                            CompareOp          compareOp_               = CompareOp::eNever,
                                            float              minLod_                  = {},
                                            float              maxLod_                  = {},
                                            BorderColor        borderColor_             = BorderColor::eFloatTransparentBlack,
                                            Bool32             unnormalizedCoordinates_ = {},
                                            void const *       pNext_                   = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , magFilter{ magFilter_ }
      , minFilter{ minFilter_ }
      , mipmapMode{ mipmapMode_ }
      , addressModeU{ addressModeU_ }
      , addressModeV{ addressModeV_ }
      , addressModeW{ addressModeW_ }
      , mipLodBias{ mipLodBias_ }
      , anisotropyEnable{ anisotropyEnable_ }
      , maxAnisotropy{ maxAnisotropy_ }
      , compareEnable{ compareEnable_ }
      , compareOp{ compareOp_ }
      , minLod{ minLod_ }
      , maxLod{ maxLod_ }
      , borderColor{ borderColor_ }
      , unnormalizedCoordinates{ unnormalizedCoordinates_ }
    {
    }

    VULKAN_HPP_CONSTEXPR SamplerCreateInfo( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SamplerCreateInfo( *reinterpret_cast<SamplerCreateInfo const *>( &rhs ) ) {}

    SamplerCreateInfo & operator=( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    SamplerCreateInfo & operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<SamplerCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setFlags( SamplerCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setFlags( SamplerCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMagFilter( Filter magFilter_ ) & VULKAN_HPP_NOEXCEPT
    {
      magFilter = magFilter_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMagFilter( Filter magFilter_ ) && VULKAN_HPP_NOEXCEPT
    {
      magFilter = magFilter_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMinFilter( Filter minFilter_ ) & VULKAN_HPP_NOEXCEPT
    {
      minFilter = minFilter_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMinFilter( Filter minFilter_ ) && VULKAN_HPP_NOEXCEPT
    {
      minFilter = minFilter_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMipmapMode( SamplerMipmapMode mipmapMode_ ) & VULKAN_HPP_NOEXCEPT
    {
      mipmapMode = mipmapMode_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMipmapMode( SamplerMipmapMode mipmapMode_ ) && VULKAN_HPP_NOEXCEPT
    {
      mipmapMode = mipmapMode_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAddressModeU( SamplerAddressMode addressModeU_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressModeU = addressModeU_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAddressModeU( SamplerAddressMode addressModeU_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressModeU = addressModeU_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAddressModeV( SamplerAddressMode addressModeV_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressModeV = addressModeV_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAddressModeV( SamplerAddressMode addressModeV_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressModeV = addressModeV_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAddressModeW( SamplerAddressMode addressModeW_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressModeW = addressModeW_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAddressModeW( SamplerAddressMode addressModeW_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressModeW = addressModeW_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMipLodBias( float mipLodBias_ ) & VULKAN_HPP_NOEXCEPT
    {
      mipLodBias = mipLodBias_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMipLodBias( float mipLodBias_ ) && VULKAN_HPP_NOEXCEPT
    {
      mipLodBias = mipLodBias_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAnisotropyEnable( Bool32 anisotropyEnable_ ) & VULKAN_HPP_NOEXCEPT
    {
      anisotropyEnable = anisotropyEnable_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAnisotropyEnable( Bool32 anisotropyEnable_ ) && VULKAN_HPP_NOEXCEPT
    {
      anisotropyEnable = anisotropyEnable_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMaxAnisotropy( float maxAnisotropy_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxAnisotropy = maxAnisotropy_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMaxAnisotropy( float maxAnisotropy_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxAnisotropy = maxAnisotropy_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setCompareEnable( Bool32 compareEnable_ ) & VULKAN_HPP_NOEXCEPT
    {
      compareEnable = compareEnable_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setCompareEnable( Bool32 compareEnable_ ) && VULKAN_HPP_NOEXCEPT
    {
      compareEnable = compareEnable_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setCompareOp( CompareOp compareOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      compareOp = compareOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setCompareOp( CompareOp compareOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      compareOp = compareOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMinLod( float minLod_ ) & VULKAN_HPP_NOEXCEPT
    {
      minLod = minLod_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMinLod( float minLod_ ) && VULKAN_HPP_NOEXCEPT
    {
      minLod = minLod_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMaxLod( float maxLod_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxLod = maxLod_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMaxLod( float maxLod_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxLod = maxLod_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setBorderColor( BorderColor borderColor_ ) & VULKAN_HPP_NOEXCEPT
    {
      borderColor = borderColor_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setBorderColor( BorderColor borderColor_ ) && VULKAN_HPP_NOEXCEPT
    {
      borderColor = borderColor_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) & VULKAN_HPP_NOEXCEPT
    {
      unnormalizedCoordinates = unnormalizedCoordinates_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) && VULKAN_HPP_NOEXCEPT
    {
      unnormalizedCoordinates = unnormalizedCoordinates_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSamplerCreateInfo const *>( this );
    }

    operator VkSamplerCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkSamplerCreateInfo *>( this );
    }

    operator VkSamplerCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSamplerCreateInfo const *>( this );
    }

    operator VkSamplerCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkSamplerCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               SamplerCreateFlags const &,
               Filter const &,
               Filter const &,
               SamplerMipmapMode const &,
               SamplerAddressMode const &,
               SamplerAddressMode const &,
               SamplerAddressMode const &,
               float const &,
               Bool32 const &,
               float const &,
               Bool32 const &,
               CompareOp const &,
               float const &,
               float const &,
               BorderColor const &,
               Bool32 const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType,
                       pNext,
                       flags,
                       magFilter,
                       minFilter,
                       mipmapMode,
                       addressModeU,
                       addressModeV,
                       addressModeW,
                       mipLodBias,
                       anisotropyEnable,
                       maxAnisotropy,
                       compareEnable,
                       compareOp,
                       minLod,
                       maxLod,
                       borderColor,
                       unnormalizedCoordinates );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( SamplerCreateInfo const & ) const = default;
#else
    bool operator==( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( magFilter == rhs.magFilter ) && ( minFilter == rhs.minFilter ) &&
             ( mipmapMode == rhs.mipmapMode ) && ( addressModeU == rhs.addressModeU ) && ( addressModeV == rhs.addressModeV ) &&
             ( addressModeW == rhs.addressModeW ) && ( mipLodBias == rhs.mipLodBias ) && ( anisotropyEnable == rhs.anisotropyEnable ) &&
             ( maxAnisotropy == rhs.maxAnisotropy ) && ( compareEnable == rhs.compareEnable ) && ( compareOp == rhs.compareOp ) && ( minLod == rhs.minLod ) &&
             ( maxLod == rhs.maxLod ) && ( borderColor == rhs.borderColor ) && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates );
#  endif
    }

    bool operator!=( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType      sType                   = StructureType::eSamplerCreateInfo;
    void const *       pNext                   = {};
    SamplerCreateFlags flags                   = {};
    Filter             magFilter               = Filter::eNearest;
    Filter             minFilter               = Filter::eNearest;
    SamplerMipmapMode  mipmapMode              = SamplerMipmapMode::eNearest;
    SamplerAddressMode addressModeU            = SamplerAddressMode::eRepeat;
    SamplerAddressMode addressModeV            = SamplerAddressMode::eRepeat;
    SamplerAddressMode addressModeW            = SamplerAddressMode::eRepeat;
    float              mipLodBias              = {};
    Bool32             anisotropyEnable        = {};
    float              maxAnisotropy           = {};
    Bool32             compareEnable           = {};
    CompareOp          compareOp               = CompareOp::eNever;
    float              minLod                  = {};
    float              maxLod                  = {};
    BorderColor        borderColor             = BorderColor::eFloatTransparentBlack;
    Bool32             unnormalizedCoordinates = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkSamplerCreateInfo>
  {
    using Type = SamplerCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eSamplerCreateInfo>
  {
    using Type = SamplerCreateInfo;
  };

  // wrapper struct for struct VkDescriptorMappingSourceConstantOffsetEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceConstantOffsetEXT.html
  struct DescriptorMappingSourceConstantOffsetEXT
  {
    using NativeType = VkDescriptorMappingSourceConstantOffsetEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceConstantOffsetEXT( uint32_t                  heapOffset_             = {},
                                                                   uint32_t                  heapArrayStride_        = {},
                                                                   SamplerCreateInfo const * pEmbeddedSampler_       = {},
                                                                   uint32_t                  samplerHeapOffset_      = {},
                                                                   uint32_t                  samplerHeapArrayStride_ = {} ) VULKAN_HPP_NOEXCEPT
      : heapOffset{ heapOffset_ }
      , heapArrayStride{ heapArrayStride_ }
      , pEmbeddedSampler{ pEmbeddedSampler_ }
      , samplerHeapOffset{ samplerHeapOffset_ }
      , samplerHeapArrayStride{ samplerHeapArrayStride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceConstantOffsetEXT( DescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorMappingSourceConstantOffsetEXT( VkDescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorMappingSourceConstantOffsetEXT( *reinterpret_cast<DescriptorMappingSourceConstantOffsetEXT const *>( &rhs ) )
    {
    }

    DescriptorMappingSourceConstantOffsetEXT & operator=( DescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorMappingSourceConstantOffsetEXT & operator=( VkDescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorMappingSourceConstantOffsetEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapArrayStride = heapArrayStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapArrayStride = heapArrayStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) & VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapArrayStride = samplerHeapArrayStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapArrayStride = samplerHeapArrayStride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorMappingSourceConstantOffsetEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceConstantOffsetEXT const *>( this );
    }

    operator VkDescriptorMappingSourceConstantOffsetEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceConstantOffsetEXT *>( this );
    }

    operator VkDescriptorMappingSourceConstantOffsetEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceConstantOffsetEXT const *>( this );
    }

    operator VkDescriptorMappingSourceConstantOffsetEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceConstantOffsetEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, SamplerCreateInfo const * const &, uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( heapOffset, heapArrayStride, pEmbeddedSampler, samplerHeapOffset, samplerHeapArrayStride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorMappingSourceConstantOffsetEXT const & ) const = default;
#else
    bool operator==( DescriptorMappingSourceConstantOffsetEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( heapOffset == rhs.heapOffset ) && ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) &&
             ( samplerHeapOffset == rhs.samplerHeapOffset ) && ( samplerHeapArrayStride == rhs.samplerHeapArrayStride );
#  endif
    }

    bool operator!=( DescriptorMappingSourceConstantOffsetEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t                  heapOffset             = {};
    uint32_t                  heapArrayStride        = {};
    SamplerCreateInfo const * pEmbeddedSampler       = {};
    uint32_t                  samplerHeapOffset      = {};
    uint32_t                  samplerHeapArrayStride = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorMappingSourceConstantOffsetEXT>
  {
    using Type = DescriptorMappingSourceConstantOffsetEXT;
  };
#endif

  // wrapper struct for struct VkDescriptorMappingSourcePushIndexEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourcePushIndexEXT.html
  struct DescriptorMappingSourcePushIndexEXT
  {
    using NativeType = VkDescriptorMappingSourcePushIndexEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorMappingSourcePushIndexEXT( uint32_t                  heapOffset_                   = {},
                                                              uint32_t                  pushOffset_                   = {},
                                                              uint32_t                  heapIndexStride_              = {},
                                                              uint32_t                  heapArrayStride_              = {},
                                                              SamplerCreateInfo const * pEmbeddedSampler_             = {},
                                                              Bool32                    useCombinedImageSamplerIndex_ = {},
                                                              uint32_t                  samplerHeapOffset_            = {},
                                                              uint32_t                  samplerPushOffset_            = {},
                                                              uint32_t                  samplerHeapIndexStride_       = {},
                                                              uint32_t                  samplerHeapArrayStride_       = {} ) VULKAN_HPP_NOEXCEPT
      : heapOffset{ heapOffset_ }
      , pushOffset{ pushOffset_ }
      , heapIndexStride{ heapIndexStride_ }
      , heapArrayStride{ heapArrayStride_ }
      , pEmbeddedSampler{ pEmbeddedSampler_ }
      , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ }
      , samplerHeapOffset{ samplerHeapOffset_ }
      , samplerPushOffset{ samplerPushOffset_ }
      , samplerHeapIndexStride{ samplerHeapIndexStride_ }
      , samplerHeapArrayStride{ samplerHeapArrayStride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorMappingSourcePushIndexEXT( DescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorMappingSourcePushIndexEXT( VkDescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorMappingSourcePushIndexEXT( *reinterpret_cast<DescriptorMappingSourcePushIndexEXT const *>( &rhs ) )
    {
    }

    DescriptorMappingSourcePushIndexEXT & operator=( DescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorMappingSourcePushIndexEXT & operator=( VkDescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorMappingSourcePushIndexEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapIndexStride = heapIndexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapIndexStride = heapIndexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapArrayStride = heapArrayStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapArrayStride = heapArrayStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) & VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) && VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerPushOffset( uint32_t samplerPushOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerPushOffset = samplerPushOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerPushOffset( uint32_t samplerPushOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerPushOffset = samplerPushOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapIndexStride = samplerHeapIndexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapIndexStride = samplerHeapIndexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapArrayStride = samplerHeapArrayStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapArrayStride = samplerHeapArrayStride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorMappingSourcePushIndexEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourcePushIndexEXT const *>( this );
    }

    operator VkDescriptorMappingSourcePushIndexEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourcePushIndexEXT *>( this );
    }

    operator VkDescriptorMappingSourcePushIndexEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourcePushIndexEXT const *>( this );
    }

    operator VkDescriptorMappingSourcePushIndexEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourcePushIndexEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               SamplerCreateInfo const * const &,
               Bool32 const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( heapOffset,
                       pushOffset,
                       heapIndexStride,
                       heapArrayStride,
                       pEmbeddedSampler,
                       useCombinedImageSamplerIndex,
                       samplerHeapOffset,
                       samplerPushOffset,
                       samplerHeapIndexStride,
                       samplerHeapArrayStride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorMappingSourcePushIndexEXT const & ) const = default;
#else
    bool operator==( DescriptorMappingSourcePushIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ) && ( heapIndexStride == rhs.heapIndexStride ) &&
             ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) &&
             ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) &&
             ( samplerPushOffset == rhs.samplerPushOffset ) && ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ) &&
             ( samplerHeapArrayStride == rhs.samplerHeapArrayStride );
#  endif
    }

    bool operator!=( DescriptorMappingSourcePushIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t                  heapOffset                   = {};
    uint32_t                  pushOffset                   = {};
    uint32_t                  heapIndexStride              = {};
    uint32_t                  heapArrayStride              = {};
    SamplerCreateInfo const * pEmbeddedSampler             = {};
    Bool32                    useCombinedImageSamplerIndex = {};
    uint32_t                  samplerHeapOffset            = {};
    uint32_t                  samplerPushOffset            = {};
    uint32_t                  samplerHeapIndexStride       = {};
    uint32_t                  samplerHeapArrayStride       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorMappingSourcePushIndexEXT>
  {
    using Type = DescriptorMappingSourcePushIndexEXT;
  };
#endif

  // wrapper struct for struct VkDescriptorMappingSourceIndirectIndexEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceIndirectIndexEXT.html
  struct DescriptorMappingSourceIndirectIndexEXT
  {
    using NativeType = VkDescriptorMappingSourceIndirectIndexEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexEXT( uint32_t                  heapOffset_                   = {},
                                                                  uint32_t                  pushOffset_                   = {},
                                                                  uint32_t                  addressOffset_                = {},
                                                                  uint32_t                  heapIndexStride_              = {},
                                                                  uint32_t                  heapArrayStride_              = {},
                                                                  SamplerCreateInfo const * pEmbeddedSampler_             = {},
                                                                  Bool32                    useCombinedImageSamplerIndex_ = {},
                                                                  uint32_t                  samplerHeapOffset_            = {},
                                                                  uint32_t                  samplerPushOffset_            = {},
                                                                  uint32_t                  samplerAddressOffset_         = {},
                                                                  uint32_t                  samplerHeapIndexStride_       = {},
                                                                  uint32_t                  samplerHeapArrayStride_       = {} ) VULKAN_HPP_NOEXCEPT
      : heapOffset{ heapOffset_ }
      , pushOffset{ pushOffset_ }
      , addressOffset{ addressOffset_ }
      , heapIndexStride{ heapIndexStride_ }
      , heapArrayStride{ heapArrayStride_ }
      , pEmbeddedSampler{ pEmbeddedSampler_ }
      , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ }
      , samplerHeapOffset{ samplerHeapOffset_ }
      , samplerPushOffset{ samplerPushOffset_ }
      , samplerAddressOffset{ samplerAddressOffset_ }
      , samplerHeapIndexStride{ samplerHeapIndexStride_ }
      , samplerHeapArrayStride{ samplerHeapArrayStride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexEXT( DescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorMappingSourceIndirectIndexEXT( VkDescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorMappingSourceIndirectIndexEXT( *reinterpret_cast<DescriptorMappingSourceIndirectIndexEXT const *>( &rhs ) )
    {
    }

    DescriptorMappingSourceIndirectIndexEXT & operator=( DescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorMappingSourceIndirectIndexEXT & operator=( VkDescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorMappingSourceIndirectIndexEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setAddressOffset( uint32_t addressOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressOffset = addressOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setAddressOffset( uint32_t addressOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressOffset = addressOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapIndexStride = heapIndexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapIndexStride = heapIndexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapArrayStride = heapArrayStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapArrayStride = heapArrayStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) & VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) && VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerPushOffset( uint32_t samplerPushOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerPushOffset = samplerPushOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerPushOffset( uint32_t samplerPushOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerPushOffset = samplerPushOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerAddressOffset = samplerAddressOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerAddressOffset = samplerAddressOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapIndexStride = samplerHeapIndexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapIndexStride = samplerHeapIndexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapArrayStride = samplerHeapArrayStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapArrayStride = samplerHeapArrayStride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorMappingSourceIndirectIndexEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceIndirectIndexEXT const *>( this );
    }

    operator VkDescriptorMappingSourceIndirectIndexEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceIndirectIndexEXT *>( this );
    }

    operator VkDescriptorMappingSourceIndirectIndexEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceIndirectIndexEXT const *>( this );
    }

    operator VkDescriptorMappingSourceIndirectIndexEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceIndirectIndexEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               SamplerCreateInfo const * const &,
               Bool32 const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( heapOffset,
                       pushOffset,
                       addressOffset,
                       heapIndexStride,
                       heapArrayStride,
                       pEmbeddedSampler,
                       useCombinedImageSamplerIndex,
                       samplerHeapOffset,
                       samplerPushOffset,
                       samplerAddressOffset,
                       samplerHeapIndexStride,
                       samplerHeapArrayStride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorMappingSourceIndirectIndexEXT const & ) const = default;
#else
    bool operator==( DescriptorMappingSourceIndirectIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ) && ( addressOffset == rhs.addressOffset ) &&
             ( heapIndexStride == rhs.heapIndexStride ) && ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) &&
             ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) &&
             ( samplerPushOffset == rhs.samplerPushOffset ) && ( samplerAddressOffset == rhs.samplerAddressOffset ) &&
             ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ) && ( samplerHeapArrayStride == rhs.samplerHeapArrayStride );
#  endif
    }

    bool operator!=( DescriptorMappingSourceIndirectIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t                  heapOffset                   = {};
    uint32_t                  pushOffset                   = {};
    uint32_t                  addressOffset                = {};
    uint32_t                  heapIndexStride              = {};
    uint32_t                  heapArrayStride              = {};
    SamplerCreateInfo const * pEmbeddedSampler             = {};
    Bool32                    useCombinedImageSamplerIndex = {};
    uint32_t                  samplerHeapOffset            = {};
    uint32_t                  samplerPushOffset            = {};
    uint32_t                  samplerAddressOffset         = {};
    uint32_t                  samplerHeapIndexStride       = {};
    uint32_t                  samplerHeapArrayStride       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorMappingSourceIndirectIndexEXT>
  {
    using Type = DescriptorMappingSourceIndirectIndexEXT;
  };
#endif

  // wrapper struct for struct VkDescriptorMappingSourceIndirectIndexArrayEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceIndirectIndexArrayEXT.html
  struct DescriptorMappingSourceIndirectIndexArrayEXT
  {
    using NativeType = VkDescriptorMappingSourceIndirectIndexArrayEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexArrayEXT( uint32_t                  heapOffset_                   = {},
                                                                       uint32_t                  pushOffset_                   = {},
                                                                       uint32_t                  addressOffset_                = {},
                                                                       uint32_t                  heapIndexStride_              = {},
                                                                       SamplerCreateInfo const * pEmbeddedSampler_             = {},
                                                                       Bool32                    useCombinedImageSamplerIndex_ = {},
                                                                       uint32_t                  samplerHeapOffset_            = {},
                                                                       uint32_t                  samplerPushOffset_            = {},
                                                                       uint32_t                  samplerAddressOffset_         = {},
                                                                       uint32_t                  samplerHeapIndexStride_       = {} ) VULKAN_HPP_NOEXCEPT
      : heapOffset{ heapOffset_ }
      , pushOffset{ pushOffset_ }
      , addressOffset{ addressOffset_ }
      , heapIndexStride{ heapIndexStride_ }
      , pEmbeddedSampler{ pEmbeddedSampler_ }
      , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ }
      , samplerHeapOffset{ samplerHeapOffset_ }
      , samplerPushOffset{ samplerPushOffset_ }
      , samplerAddressOffset{ samplerAddressOffset_ }
      , samplerHeapIndexStride{ samplerHeapIndexStride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexArrayEXT( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorMappingSourceIndirectIndexArrayEXT( VkDescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorMappingSourceIndirectIndexArrayEXT( *reinterpret_cast<DescriptorMappingSourceIndirectIndexArrayEXT const *>( &rhs ) )
    {
    }

    DescriptorMappingSourceIndirectIndexArrayEXT & operator=( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorMappingSourceIndirectIndexArrayEXT & operator=( VkDescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorMappingSourceIndirectIndexArrayEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setAddressOffset( uint32_t addressOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressOffset = addressOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setAddressOffset( uint32_t addressOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressOffset = addressOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapIndexStride = heapIndexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapIndexStride = heapIndexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerPushOffset( uint32_t samplerPushOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerPushOffset = samplerPushOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerPushOffset( uint32_t samplerPushOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerPushOffset = samplerPushOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerAddressOffset = samplerAddressOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerAddressOffset = samplerAddressOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapIndexStride = samplerHeapIndexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapIndexStride = samplerHeapIndexStride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorMappingSourceIndirectIndexArrayEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceIndirectIndexArrayEXT const *>( this );
    }

    operator VkDescriptorMappingSourceIndirectIndexArrayEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceIndirectIndexArrayEXT *>( this );
    }

    operator VkDescriptorMappingSourceIndirectIndexArrayEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceIndirectIndexArrayEXT const *>( this );
    }

    operator VkDescriptorMappingSourceIndirectIndexArrayEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceIndirectIndexArrayEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               SamplerCreateInfo const * const &,
               Bool32 const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( heapOffset,
                       pushOffset,
                       addressOffset,
                       heapIndexStride,
                       pEmbeddedSampler,
                       useCombinedImageSamplerIndex,
                       samplerHeapOffset,
                       samplerPushOffset,
                       samplerAddressOffset,
                       samplerHeapIndexStride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorMappingSourceIndirectIndexArrayEXT const & ) const = default;
#else
    bool operator==( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ) && ( addressOffset == rhs.addressOffset ) &&
             ( heapIndexStride == rhs.heapIndexStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) &&
             ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) &&
             ( samplerPushOffset == rhs.samplerPushOffset ) && ( samplerAddressOffset == rhs.samplerAddressOffset ) &&
             ( samplerHeapIndexStride == rhs.samplerHeapIndexStride );
#  endif
    }

    bool operator!=( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t                  heapOffset                   = {};
    uint32_t                  pushOffset                   = {};
    uint32_t                  addressOffset                = {};
    uint32_t                  heapIndexStride              = {};
    SamplerCreateInfo const * pEmbeddedSampler             = {};
    Bool32                    useCombinedImageSamplerIndex = {};
    uint32_t                  samplerHeapOffset            = {};
    uint32_t                  samplerPushOffset            = {};
    uint32_t                  samplerAddressOffset         = {};
    uint32_t                  samplerHeapIndexStride       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorMappingSourceIndirectIndexArrayEXT>
  {
    using Type = DescriptorMappingSourceIndirectIndexArrayEXT;
  };
#endif

  // wrapper struct for struct VkDescriptorMappingSourceHeapDataEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceHeapDataEXT.html
  struct DescriptorMappingSourceHeapDataEXT
  {
    using NativeType = VkDescriptorMappingSourceHeapDataEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceHeapDataEXT( uint32_t heapOffset_ = {}, uint32_t pushOffset_ = {} ) VULKAN_HPP_NOEXCEPT
      : heapOffset{ heapOffset_ }
      , pushOffset{ pushOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceHeapDataEXT( DescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorMappingSourceHeapDataEXT( VkDescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorMappingSourceHeapDataEXT( *reinterpret_cast<DescriptorMappingSourceHeapDataEXT const *>( &rhs ) )
    {
    }

    DescriptorMappingSourceHeapDataEXT & operator=( DescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorMappingSourceHeapDataEXT & operator=( VkDescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorMappingSourceHeapDataEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorMappingSourceHeapDataEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceHeapDataEXT const *>( this );
    }

    operator VkDescriptorMappingSourceHeapDataEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceHeapDataEXT *>( this );
    }

    operator VkDescriptorMappingSourceHeapDataEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceHeapDataEXT const *>( this );
    }

    operator VkDescriptorMappingSourceHeapDataEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceHeapDataEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( heapOffset, pushOffset );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorMappingSourceHeapDataEXT const & ) const = default;
#else
    bool operator==( DescriptorMappingSourceHeapDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset );
#  endif
    }

    bool operator!=( DescriptorMappingSourceHeapDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t heapOffset = {};
    uint32_t pushOffset = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorMappingSourceHeapDataEXT>
  {
    using Type = DescriptorMappingSourceHeapDataEXT;
  };
#endif

  // wrapper struct for struct VkDescriptorMappingSourceIndirectAddressEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceIndirectAddressEXT.html
  struct DescriptorMappingSourceIndirectAddressEXT
  {
    using NativeType = VkDescriptorMappingSourceIndirectAddressEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectAddressEXT( uint32_t pushOffset_ = {}, uint32_t addressOffset_ = {} ) VULKAN_HPP_NOEXCEPT
      : pushOffset{ pushOffset_ }
      , addressOffset{ addressOffset_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectAddressEXT( DescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorMappingSourceIndirectAddressEXT( VkDescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorMappingSourceIndirectAddressEXT( *reinterpret_cast<DescriptorMappingSourceIndirectAddressEXT const *>( &rhs ) )
    {
    }

    DescriptorMappingSourceIndirectAddressEXT & operator=( DescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorMappingSourceIndirectAddressEXT & operator=( VkDescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorMappingSourceIndirectAddressEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      pushOffset = pushOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT & setAddressOffset( uint32_t addressOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      addressOffset = addressOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT && setAddressOffset( uint32_t addressOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      addressOffset = addressOffset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorMappingSourceIndirectAddressEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceIndirectAddressEXT const *>( this );
    }

    operator VkDescriptorMappingSourceIndirectAddressEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceIndirectAddressEXT *>( this );
    }

    operator VkDescriptorMappingSourceIndirectAddressEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceIndirectAddressEXT const *>( this );
    }

    operator VkDescriptorMappingSourceIndirectAddressEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceIndirectAddressEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( pushOffset, addressOffset );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorMappingSourceIndirectAddressEXT const & ) const = default;
#else
    bool operator==( DescriptorMappingSourceIndirectAddressEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( pushOffset == rhs.pushOffset ) && ( addressOffset == rhs.addressOffset );
#  endif
    }

    bool operator!=( DescriptorMappingSourceIndirectAddressEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t pushOffset    = {};
    uint32_t addressOffset = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorMappingSourceIndirectAddressEXT>
  {
    using Type = DescriptorMappingSourceIndirectAddressEXT;
  };
#endif

  // wrapper struct for struct VkDescriptorMappingSourceShaderRecordIndexEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceShaderRecordIndexEXT.html
  struct DescriptorMappingSourceShaderRecordIndexEXT
  {
    using NativeType = VkDescriptorMappingSourceShaderRecordIndexEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceShaderRecordIndexEXT( uint32_t                  heapOffset_                   = {},
                                                                      uint32_t                  shaderRecordOffset_           = {},
                                                                      uint32_t                  heapIndexStride_              = {},
                                                                      uint32_t                  heapArrayStride_              = {},
                                                                      SamplerCreateInfo const * pEmbeddedSampler_             = {},
                                                                      Bool32                    useCombinedImageSamplerIndex_ = {},
                                                                      uint32_t                  samplerHeapOffset_            = {},
                                                                      uint32_t                  samplerShaderRecordOffset_    = {},
                                                                      uint32_t                  samplerHeapIndexStride_       = {},
                                                                      uint32_t                  samplerHeapArrayStride_       = {} ) VULKAN_HPP_NOEXCEPT
      : heapOffset{ heapOffset_ }
      , shaderRecordOffset{ shaderRecordOffset_ }
      , heapIndexStride{ heapIndexStride_ }
      , heapArrayStride{ heapArrayStride_ }
      , pEmbeddedSampler{ pEmbeddedSampler_ }
      , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ }
      , samplerHeapOffset{ samplerHeapOffset_ }
      , samplerShaderRecordOffset{ samplerShaderRecordOffset_ }
      , samplerHeapIndexStride{ samplerHeapIndexStride_ }
      , samplerHeapArrayStride{ samplerHeapArrayStride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorMappingSourceShaderRecordIndexEXT( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorMappingSourceShaderRecordIndexEXT( VkDescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorMappingSourceShaderRecordIndexEXT( *reinterpret_cast<DescriptorMappingSourceShaderRecordIndexEXT const *>( &rhs ) )
    {
    }

    DescriptorMappingSourceShaderRecordIndexEXT & operator=( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorMappingSourceShaderRecordIndexEXT & operator=( VkDescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorMappingSourceShaderRecordIndexEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapOffset = heapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setShaderRecordOffset( uint32_t shaderRecordOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      shaderRecordOffset = shaderRecordOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setShaderRecordOffset( uint32_t shaderRecordOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      shaderRecordOffset = shaderRecordOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapIndexStride = heapIndexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapIndexStride = heapIndexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapArrayStride = heapArrayStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapArrayStride = heapArrayStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setPEmbeddedSampler( SamplerCreateInfo const * pEmbeddedSampler_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pEmbeddedSampler = pEmbeddedSampler_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapOffset = samplerHeapOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerShaderRecordOffset( uint32_t samplerShaderRecordOffset_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      samplerShaderRecordOffset = samplerShaderRecordOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerShaderRecordOffset( uint32_t samplerShaderRecordOffset_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      samplerShaderRecordOffset = samplerShaderRecordOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapIndexStride = samplerHeapIndexStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapIndexStride = samplerHeapIndexStride_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerHeapArrayStride = samplerHeapArrayStride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerHeapArrayStride = samplerHeapArrayStride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorMappingSourceShaderRecordIndexEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceShaderRecordIndexEXT const *>( this );
    }

    operator VkDescriptorMappingSourceShaderRecordIndexEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorMappingSourceShaderRecordIndexEXT *>( this );
    }

    operator VkDescriptorMappingSourceShaderRecordIndexEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceShaderRecordIndexEXT const *>( this );
    }

    operator VkDescriptorMappingSourceShaderRecordIndexEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorMappingSourceShaderRecordIndexEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               SamplerCreateInfo const * const &,
               Bool32 const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( heapOffset,
                       shaderRecordOffset,
                       heapIndexStride,
                       heapArrayStride,
                       pEmbeddedSampler,
                       useCombinedImageSamplerIndex,
                       samplerHeapOffset,
                       samplerShaderRecordOffset,
                       samplerHeapIndexStride,
                       samplerHeapArrayStride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorMappingSourceShaderRecordIndexEXT const & ) const = default;
#else
    bool operator==( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( heapOffset == rhs.heapOffset ) && ( shaderRecordOffset == rhs.shaderRecordOffset ) && ( heapIndexStride == rhs.heapIndexStride ) &&
             ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) &&
             ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) &&
             ( samplerShaderRecordOffset == rhs.samplerShaderRecordOffset ) && ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ) &&
             ( samplerHeapArrayStride == rhs.samplerHeapArrayStride );
#  endif
    }

    bool operator!=( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t                  heapOffset                   = {};
    uint32_t                  shaderRecordOffset           = {};
    uint32_t                  heapIndexStride              = {};
    uint32_t                  heapArrayStride              = {};
    SamplerCreateInfo const * pEmbeddedSampler             = {};
    Bool32                    useCombinedImageSamplerIndex = {};
    uint32_t                  samplerHeapOffset            = {};
    uint32_t                  samplerShaderRecordOffset    = {};
    uint32_t                  samplerHeapIndexStride       = {};
    uint32_t                  samplerHeapArrayStride       = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorMappingSourceShaderRecordIndexEXT>
  {
    using Type = DescriptorMappingSourceShaderRecordIndexEXT;
  };
#endif

  union DescriptorMappingSourceDataEXT
  {
    using NativeType = VkDescriptorMappingSourceDataEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceConstantOffsetEXT constantOffset_ = {} ) : constantOffset( constantOffset_ )
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourcePushIndexEXT pushIndex_ ) : pushIndex( pushIndex_ ) {}

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceIndirectIndexEXT indirectIndex_ ) : indirectIndex( indirectIndex_ ) {}

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray_ )
      : indirectIndexArray( indirectIndexArray_ )
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceHeapDataEXT heapData_ ) : heapData( heapData_ ) {}

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( uint32_t uint32_t_ ) : pushDataOffset( uint32_t_ ) {}

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceIndirectAddressEXT indirectAddress_ ) : indirectAddress( indirectAddress_ )
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex_ )
      : shaderRecordIndex( shaderRecordIndex_ )
    {
    }
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setConstantOffset( DescriptorMappingSourceConstantOffsetEXT const & constantOffset_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      constantOffset = constantOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setConstantOffset( DescriptorMappingSourceConstantOffsetEXT const & constantOffset_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      constantOffset = constantOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setPushIndex( DescriptorMappingSourcePushIndexEXT const & pushIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      pushIndex = pushIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setPushIndex( DescriptorMappingSourcePushIndexEXT const & pushIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      pushIndex = pushIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setIndirectIndex( DescriptorMappingSourceIndirectIndexEXT const & indirectIndex_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      indirectIndex = indirectIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setIndirectIndex( DescriptorMappingSourceIndirectIndexEXT const & indirectIndex_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indirectIndex = indirectIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setIndirectIndexArray( DescriptorMappingSourceIndirectIndexArrayEXT const & indirectIndexArray_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      indirectIndexArray = indirectIndexArray_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT &&
      setIndirectIndexArray( DescriptorMappingSourceIndirectIndexArrayEXT const & indirectIndexArray_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indirectIndexArray = indirectIndexArray_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setHeapData( DescriptorMappingSourceHeapDataEXT const & heapData_ ) & VULKAN_HPP_NOEXCEPT
    {
      heapData = heapData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setHeapData( DescriptorMappingSourceHeapDataEXT const & heapData_ ) && VULKAN_HPP_NOEXCEPT
    {
      heapData = heapData_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setPushDataOffset( uint32_t pushDataOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      pushDataOffset = pushDataOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setPushDataOffset( uint32_t pushDataOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      pushDataOffset = pushDataOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setPushAddressOffset( uint32_t pushAddressOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      pushAddressOffset = pushAddressOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setPushAddressOffset( uint32_t pushAddressOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      pushAddressOffset = pushAddressOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setIndirectAddress( DescriptorMappingSourceIndirectAddressEXT const & indirectAddress_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      indirectAddress = indirectAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setIndirectAddress( DescriptorMappingSourceIndirectAddressEXT const & indirectAddress_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      indirectAddress = indirectAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setShaderRecordIndex( DescriptorMappingSourceShaderRecordIndexEXT const & shaderRecordIndex_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      shaderRecordIndex = shaderRecordIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setShaderRecordIndex( DescriptorMappingSourceShaderRecordIndexEXT const & shaderRecordIndex_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      shaderRecordIndex = shaderRecordIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setShaderRecordDataOffset( uint32_t shaderRecordDataOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      shaderRecordDataOffset = shaderRecordDataOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setShaderRecordDataOffset( uint32_t shaderRecordDataOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      shaderRecordDataOffset = shaderRecordDataOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setShaderRecordAddressOffset( uint32_t shaderRecordAddressOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      shaderRecordAddressOffset = shaderRecordAddressOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setShaderRecordAddressOffset( uint32_t shaderRecordAddressOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      shaderRecordAddressOffset = shaderRecordAddressOffset_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorMappingSourceDataEXT const &() const
    {
      return *reinterpret_cast<VkDescriptorMappingSourceDataEXT const *>( this );
    }

    operator VkDescriptorMappingSourceDataEXT &()
    {
      return *reinterpret_cast<VkDescriptorMappingSourceDataEXT *>( this );
    }

#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    DescriptorMappingSourceConstantOffsetEXT     constantOffset;
    DescriptorMappingSourcePushIndexEXT          pushIndex;
    DescriptorMappingSourceIndirectIndexEXT      indirectIndex;
    DescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray;
    DescriptorMappingSourceHeapDataEXT           heapData;
    uint32_t                                     pushDataOffset;
    uint32_t                                     pushAddressOffset;
    DescriptorMappingSourceIndirectAddressEXT    indirectAddress;
    DescriptorMappingSourceShaderRecordIndexEXT  shaderRecordIndex;
    uint32_t                                     shaderRecordDataOffset;
    uint32_t                                     shaderRecordAddressOffset;
#else
    VkDescriptorMappingSourceConstantOffsetEXT     constantOffset;
    VkDescriptorMappingSourcePushIndexEXT          pushIndex;
    VkDescriptorMappingSourceIndirectIndexEXT      indirectIndex;
    VkDescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray;
    VkDescriptorMappingSourceHeapDataEXT           heapData;
    uint32_t                                       pushDataOffset;
    uint32_t                                       pushAddressOffset;
    VkDescriptorMappingSourceIndirectAddressEXT    indirectAddress;
    VkDescriptorMappingSourceShaderRecordIndexEXT  shaderRecordIndex;
    uint32_t                                       shaderRecordDataOffset;
    uint32_t                                       shaderRecordAddressOffset;
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorMappingSourceDataEXT>
  {
    using Type = DescriptorMappingSourceDataEXT;
  };
#endif

  // wrapper struct for struct VkDescriptorPoolSize, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolSize.html
  struct DescriptorPoolSize
  {
    using NativeType = VkDescriptorPoolSize;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler, uint32_t descriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT
      : type{ type_ }
      , descriptorCount{ descriptorCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorPoolSize( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT : DescriptorPoolSize( *reinterpret_cast<DescriptorPoolSize const *>( &rhs ) ) {}

    DescriptorPoolSize & operator=( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorPoolSize & operator=( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorPoolSize const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize & setType( DescriptorType type_ ) & VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize && setType( DescriptorType type_ ) && VULKAN_HPP_NOEXCEPT
    {
      type = type_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorCount = descriptorCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorCount = descriptorCount_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorPoolSize const *>( this );
    }

    operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorPoolSize *>( this );
    }

    operator VkDescriptorPoolSize const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorPoolSize const *>( this );
    }

    operator VkDescriptorPoolSize *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorPoolSize *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<DescriptorType const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( type, descriptorCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorPoolSize const & ) const = default;
#else
    bool operator==( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( type == rhs.type ) && ( descriptorCount == rhs.descriptorCount );
#  endif
    }

    bool operator!=( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    DescriptorType type            = DescriptorType::eSampler;
    uint32_t       descriptorCount = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorPoolSize>
  {
    using Type = DescriptorPoolSize;
  };
#endif

  // wrapper struct for struct VkDescriptorPoolCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolCreateInfo.html
  struct DescriptorPoolCreateInfo
  {
    using NativeType = VkDescriptorPoolCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorPoolCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( DescriptorPoolCreateFlags  flags_         = {},
                                                   uint32_t                   maxSets_       = {},
                                                   uint32_t                   poolSizeCount_ = {},
                                                   DescriptorPoolSize const * pPoolSizes_    = {},
                                                   void const *               pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , maxSets{ maxSets_ }
      , poolSizeCount{ poolSizeCount_ }
      , pPoolSizes{ pPoolSizes_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorPoolCreateInfo( *reinterpret_cast<DescriptorPoolCreateInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorPoolCreateInfo( DescriptorPoolCreateFlags                                 flags_,
                              uint32_t                                                  maxSets_,
                              ArrayProxyNoTemporaries<DescriptorPoolSize const> const & poolSizes_,
                              void const *                                              pNext_ = nullptr )
      : pNext( pNext_ ), flags( flags_ ), maxSets( maxSets_ ), poolSizeCount( static_cast<uint32_t>( poolSizes_.size() ) ), pPoolSizes( poolSizes_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DescriptorPoolCreateInfo & operator=( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorPoolCreateInfo & operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorPoolCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setFlags( DescriptorPoolCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setFlags( DescriptorPoolCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setMaxSets( uint32_t maxSets_ ) & VULKAN_HPP_NOEXCEPT
    {
      maxSets = maxSets_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setMaxSets( uint32_t maxSets_ ) && VULKAN_HPP_NOEXCEPT
    {
      maxSets = maxSets_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setPoolSizeCount( uint32_t poolSizeCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      poolSizeCount = poolSizeCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setPoolSizeCount( uint32_t poolSizeCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      poolSizeCount = poolSizeCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setPPoolSizes( DescriptorPoolSize const * pPoolSizes_ ) & VULKAN_HPP_NOEXCEPT
    {
      pPoolSizes = pPoolSizes_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setPPoolSizes( DescriptorPoolSize const * pPoolSizes_ ) && VULKAN_HPP_NOEXCEPT
    {
      pPoolSizes = pPoolSizes_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorPoolCreateInfo & setPoolSizes( ArrayProxyNoTemporaries<DescriptorPoolSize const> const & poolSizes_ ) VULKAN_HPP_NOEXCEPT
    {
      poolSizeCount = static_cast<uint32_t>( poolSizes_.size() );
      pPoolSizes    = poolSizes_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorPoolCreateInfo const *>( this );
    }

    operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorPoolCreateInfo *>( this );
    }

    operator VkDescriptorPoolCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorPoolCreateInfo const *>( this );
    }

    operator VkDescriptorPoolCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorPoolCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DescriptorPoolCreateFlags const &,
               uint32_t const &,
               uint32_t const &,
               DescriptorPoolSize const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorPoolCreateInfo const & ) const = default;
#else
    bool operator==( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) &&
             ( poolSizeCount == rhs.poolSizeCount ) && ( pPoolSizes == rhs.pPoolSizes );
#  endif
    }

    bool operator!=( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType              sType         = StructureType::eDescriptorPoolCreateInfo;
    void const *               pNext         = {};
    DescriptorPoolCreateFlags  flags         = {};
    uint32_t                   maxSets       = {};
    uint32_t                   poolSizeCount = {};
    DescriptorPoolSize const * pPoolSizes    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorPoolCreateInfo>
  {
    using Type = DescriptorPoolCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorPoolCreateInfo>
  {
    using Type = DescriptorPoolCreateInfo;
  };

  // wrapper struct for struct VkDescriptorPoolInlineUniformBlockCreateInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolInlineUniformBlockCreateInfo.html
  struct DescriptorPoolInlineUniformBlockCreateInfo
  {
    using NativeType = VkDescriptorPoolInlineUniformBlockCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorPoolInlineUniformBlockCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfo( uint32_t     maxInlineUniformBlockBindings_ = {},
                                                                     void const * pNext_                         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , maxInlineUniformBlockBindings{ maxInlineUniformBlockBindings_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfo( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorPoolInlineUniformBlockCreateInfo( VkDescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorPoolInlineUniformBlockCreateInfo( *reinterpret_cast<DescriptorPoolInlineUniformBlockCreateInfo const *>( &rhs ) )
    {
    }

    DescriptorPoolInlineUniformBlockCreateInfo & operator=( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorPoolInlineUniformBlockCreateInfo & operator=( VkDescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorPoolInlineUniformBlockCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo & setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo && setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorPoolInlineUniformBlockCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo const *>( this );
    }

    operator VkDescriptorPoolInlineUniformBlockCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo *>( this );
    }

    operator VkDescriptorPoolInlineUniformBlockCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo const *>( this );
    }

    operator VkDescriptorPoolInlineUniformBlockCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, maxInlineUniformBlockBindings );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfo const & ) const = default;
#else
    bool operator==( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings );
#  endif
    }

    bool operator!=( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                         = StructureType::eDescriptorPoolInlineUniformBlockCreateInfo;
    void const *  pNext                         = {};
    uint32_t      maxInlineUniformBlockBindings = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorPoolInlineUniformBlockCreateInfo>
  {
    using Type = DescriptorPoolInlineUniformBlockCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorPoolInlineUniformBlockCreateInfo>
  {
    using Type = DescriptorPoolInlineUniformBlockCreateInfo;
  };

  using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;

  // wrapper struct for struct VkDescriptorSetAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetAllocateInfo.html
  struct DescriptorSetAllocateInfo
  {
    using NativeType = VkDescriptorSetAllocateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorSetAllocateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( DescriptorPool              descriptorPool_     = {},
                                                    uint32_t                    descriptorSetCount_ = {},
                                                    DescriptorSetLayout const * pSetLayouts_        = {},
                                                    void const *                pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , descriptorPool{ descriptorPool_ }
      , descriptorSetCount{ descriptorSetCount_ }
      , pSetLayouts{ pSetLayouts_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetAllocateInfo( *reinterpret_cast<DescriptorSetAllocateInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetAllocateInfo( DescriptorPool                                             descriptorPool_,
                               ArrayProxyNoTemporaries<DescriptorSetLayout const> const & setLayouts_,
                               void const *                                               pNext_ = nullptr )
      : pNext( pNext_ ), descriptorPool( descriptorPool_ ), descriptorSetCount( static_cast<uint32_t>( setLayouts_.size() ) ), pSetLayouts( setLayouts_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DescriptorSetAllocateInfo & operator=( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetAllocateInfo & operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetAllocateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setDescriptorPool( DescriptorPool descriptorPool_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorPool = descriptorPool_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setDescriptorPool( DescriptorPool descriptorPool_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorPool = descriptorPool_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorSetCount = descriptorSetCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setDescriptorSetCount( uint32_t descriptorSetCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorSetCount = descriptorSetCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setPSetLayouts( DescriptorSetLayout const * pSetLayouts_ ) & VULKAN_HPP_NOEXCEPT
    {
      pSetLayouts = pSetLayouts_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setPSetLayouts( DescriptorSetLayout const * pSetLayouts_ ) && VULKAN_HPP_NOEXCEPT
    {
      pSetLayouts = pSetLayouts_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetAllocateInfo & setSetLayouts( ArrayProxyNoTemporaries<DescriptorSetLayout const> const & setLayouts_ ) VULKAN_HPP_NOEXCEPT
    {
      descriptorSetCount = static_cast<uint32_t>( setLayouts_.size() );
      pSetLayouts        = setLayouts_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetAllocateInfo const *>( this );
    }

    operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetAllocateInfo *>( this );
    }

    operator VkDescriptorSetAllocateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetAllocateInfo const *>( this );
    }

    operator VkDescriptorSetAllocateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetAllocateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DescriptorPool const &, uint32_t const &, DescriptorSetLayout const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorSetAllocateInfo const & ) const = default;
#else
    bool operator==( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) && ( descriptorSetCount == rhs.descriptorSetCount ) &&
             ( pSetLayouts == rhs.pSetLayouts );
#  endif
    }

    bool operator!=( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType               sType              = StructureType::eDescriptorSetAllocateInfo;
    void const *                pNext              = {};
    DescriptorPool              descriptorPool     = {};
    uint32_t                    descriptorSetCount = {};
    DescriptorSetLayout const * pSetLayouts        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetAllocateInfo>
  {
    using Type = DescriptorSetAllocateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorSetAllocateInfo>
  {
    using Type = DescriptorSetAllocateInfo;
  };

  // wrapper struct for struct VkDescriptorSetAndBindingMappingEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetAndBindingMappingEXT.html
  struct DescriptorSetAndBindingMappingEXT
  {
    using NativeType = VkDescriptorSetAndBindingMappingEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorSetAndBindingMappingEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT( uint32_t                       descriptorSet_ = {},
                                                               uint32_t                       firstBinding_  = {},
                                                               uint32_t                       bindingCount_  = {},
                                                               SpirvResourceTypeFlagsEXT      resourceMask_  = {},
                                                               DescriptorMappingSourceEXT     source_     = DescriptorMappingSourceEXT::eHeapWithConstantOffset,
                                                               DescriptorMappingSourceDataEXT sourceData_ = {},
                                                               void const *                   pNext_      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , descriptorSet{ descriptorSet_ }
      , firstBinding{ firstBinding_ }
      , bindingCount{ bindingCount_ }
      , resourceMask{ resourceMask_ }
      , source{ source_ }
      , sourceData{ sourceData_ }
    {
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT( DescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetAndBindingMappingEXT( VkDescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetAndBindingMappingEXT( *reinterpret_cast<DescriptorSetAndBindingMappingEXT const *>( &rhs ) )
    {
    }

    DescriptorSetAndBindingMappingEXT & operator=( DescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetAndBindingMappingEXT & operator=( VkDescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetAndBindingMappingEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setDescriptorSet( uint32_t descriptorSet_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorSet = descriptorSet_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setDescriptorSet( uint32_t descriptorSet_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorSet = descriptorSet_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setFirstBinding( uint32_t firstBinding_ ) & VULKAN_HPP_NOEXCEPT
    {
      firstBinding = firstBinding_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setFirstBinding( uint32_t firstBinding_ ) && VULKAN_HPP_NOEXCEPT
    {
      firstBinding = firstBinding_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setBindingCount( uint32_t bindingCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      bindingCount = bindingCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setBindingCount( uint32_t bindingCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      bindingCount = bindingCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setResourceMask( SpirvResourceTypeFlagsEXT resourceMask_ ) & VULKAN_HPP_NOEXCEPT
    {
      resourceMask = resourceMask_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setResourceMask( SpirvResourceTypeFlagsEXT resourceMask_ ) && VULKAN_HPP_NOEXCEPT
    {
      resourceMask = resourceMask_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setSource( DescriptorMappingSourceEXT source_ ) & VULKAN_HPP_NOEXCEPT
    {
      source = source_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setSource( DescriptorMappingSourceEXT source_ ) && VULKAN_HPP_NOEXCEPT
    {
      source = source_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setSourceData( DescriptorMappingSourceDataEXT const & sourceData_ ) & VULKAN_HPP_NOEXCEPT
    {
      sourceData = sourceData_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setSourceData( DescriptorMappingSourceDataEXT const & sourceData_ ) && VULKAN_HPP_NOEXCEPT
    {
      sourceData = sourceData_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorSetAndBindingMappingEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetAndBindingMappingEXT const *>( this );
    }

    operator VkDescriptorSetAndBindingMappingEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetAndBindingMappingEXT *>( this );
    }

    operator VkDescriptorSetAndBindingMappingEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetAndBindingMappingEXT const *>( this );
    }

    operator VkDescriptorSetAndBindingMappingEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetAndBindingMappingEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               uint32_t const &,
               uint32_t const &,
               uint32_t const &,
               SpirvResourceTypeFlagsEXT const &,
               DescriptorMappingSourceEXT const &,
               DescriptorMappingSourceDataEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, descriptorSet, firstBinding, bindingCount, resourceMask, source, sourceData );
    }
#endif

  public:
    StructureType                  sType         = StructureType::eDescriptorSetAndBindingMappingEXT;
    void const *                   pNext         = {};
    uint32_t                       descriptorSet = {};
    uint32_t                       firstBinding  = {};
    uint32_t                       bindingCount  = {};
    SpirvResourceTypeFlagsEXT      resourceMask  = {};
    DescriptorMappingSourceEXT     source        = DescriptorMappingSourceEXT::eHeapWithConstantOffset;
    DescriptorMappingSourceDataEXT sourceData    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetAndBindingMappingEXT>
  {
    using Type = DescriptorSetAndBindingMappingEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorSetAndBindingMappingEXT>
  {
    using Type = DescriptorSetAndBindingMappingEXT;
  };

  // wrapper struct for struct VkDescriptorSetBindingReferenceVALVE, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetBindingReferenceVALVE.html
  struct DescriptorSetBindingReferenceVALVE
  {
    using NativeType = VkDescriptorSetBindingReferenceVALVE;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorSetBindingReferenceVALVE;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorSetBindingReferenceVALVE( DescriptorSetLayout descriptorSetLayout_ = {},
                                                             uint32_t            binding_             = {},
                                                             void const *        pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , descriptorSetLayout{ descriptorSetLayout_ }
      , binding{ binding_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorSetBindingReferenceVALVE( DescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetBindingReferenceVALVE( VkDescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetBindingReferenceVALVE( *reinterpret_cast<DescriptorSetBindingReferenceVALVE const *>( &rhs ) )
    {
    }

    DescriptorSetBindingReferenceVALVE & operator=( DescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetBindingReferenceVALVE & operator=( VkDescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetBindingReferenceVALVE const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE & setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorSetLayout = descriptorSetLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE && setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorSetLayout = descriptorSetLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT
    {
      binding = binding_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT
    {
      binding = binding_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorSetBindingReferenceVALVE const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetBindingReferenceVALVE const *>( this );
    }

    operator VkDescriptorSetBindingReferenceVALVE &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetBindingReferenceVALVE *>( this );
    }

    operator VkDescriptorSetBindingReferenceVALVE const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetBindingReferenceVALVE const *>( this );
    }

    operator VkDescriptorSetBindingReferenceVALVE *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetBindingReferenceVALVE *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DescriptorSetLayout const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, descriptorSetLayout, binding );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorSetBindingReferenceVALVE const & ) const = default;
#else
    bool operator==( DescriptorSetBindingReferenceVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( binding == rhs.binding );
#  endif
    }

    bool operator!=( DescriptorSetBindingReferenceVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType       sType               = StructureType::eDescriptorSetBindingReferenceVALVE;
    void const *        pNext               = {};
    DescriptorSetLayout descriptorSetLayout = {};
    uint32_t            binding             = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetBindingReferenceVALVE>
  {
    using Type = DescriptorSetBindingReferenceVALVE;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorSetBindingReferenceVALVE>
  {
    using Type = DescriptorSetBindingReferenceVALVE;
  };

  // wrapper struct for struct VkDescriptorSetLayoutBinding, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBinding.html
  struct DescriptorSetLayoutBinding
  {
    using NativeType = VkDescriptorSetLayoutBinding;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( uint32_t         binding_            = {},
                                                     DescriptorType   descriptorType_     = DescriptorType::eSampler,
                                                     uint32_t         descriptorCount_    = {},
                                                     ShaderStageFlags stageFlags_         = {},
                                                     Sampler const *  pImmutableSamplers_ = {} ) VULKAN_HPP_NOEXCEPT
      : binding{ binding_ }
      , descriptorType{ descriptorType_ }
      , descriptorCount{ descriptorCount_ }
      , stageFlags{ stageFlags_ }
      , pImmutableSamplers{ pImmutableSamplers_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetLayoutBinding( *reinterpret_cast<DescriptorSetLayoutBinding const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetLayoutBinding( uint32_t                                       binding_,
                                DescriptorType                                 descriptorType_,
                                ShaderStageFlags                               stageFlags_,
                                ArrayProxyNoTemporaries<Sampler const> const & immutableSamplers_ )
      : binding( binding_ )
      , descriptorType( descriptorType_ )
      , descriptorCount( static_cast<uint32_t>( immutableSamplers_.size() ) )
      , stageFlags( stageFlags_ )
      , pImmutableSamplers( immutableSamplers_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DescriptorSetLayoutBinding & operator=( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetLayoutBinding & operator=( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetLayoutBinding const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT
    {
      binding = binding_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT
    {
      binding = binding_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorType = descriptorType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorType = descriptorType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorCount = descriptorCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorCount = descriptorCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      stageFlags = stageFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT
    {
      stageFlags = stageFlags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setPImmutableSamplers( Sampler const * pImmutableSamplers_ ) & VULKAN_HPP_NOEXCEPT
    {
      pImmutableSamplers = pImmutableSamplers_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setPImmutableSamplers( Sampler const * pImmutableSamplers_ ) && VULKAN_HPP_NOEXCEPT
    {
      pImmutableSamplers = pImmutableSamplers_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetLayoutBinding & setImmutableSamplers( ArrayProxyNoTemporaries<Sampler const> const & immutableSamplers_ ) VULKAN_HPP_NOEXCEPT
    {
      descriptorCount    = static_cast<uint32_t>( immutableSamplers_.size() );
      pImmutableSamplers = immutableSamplers_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutBinding const *>( this );
    }

    operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutBinding *>( this );
    }

    operator VkDescriptorSetLayoutBinding const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutBinding const *>( this );
    }

    operator VkDescriptorSetLayoutBinding *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutBinding *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, DescriptorType const &, uint32_t const &, ShaderStageFlags const &, Sampler const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorSetLayoutBinding const & ) const = default;
#else
    bool operator==( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( binding == rhs.binding ) && ( descriptorType == rhs.descriptorType ) && ( descriptorCount == rhs.descriptorCount ) &&
             ( stageFlags == rhs.stageFlags ) && ( pImmutableSamplers == rhs.pImmutableSamplers );
#  endif
    }

    bool operator!=( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t         binding            = {};
    DescriptorType   descriptorType     = DescriptorType::eSampler;
    uint32_t         descriptorCount    = {};
    ShaderStageFlags stageFlags         = {};
    Sampler const *  pImmutableSamplers = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetLayoutBinding>
  {
    using Type = DescriptorSetLayoutBinding;
  };
#endif

  // wrapper struct for struct VkDescriptorSetLayoutBindingFlagsCreateInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html
  struct DescriptorSetLayoutBindingFlagsCreateInfo
  {
    using NativeType = VkDescriptorSetLayoutBindingFlagsCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( uint32_t                       bindingCount_  = {},
                                                                    DescriptorBindingFlags const * pBindingFlags_ = {},
                                                                    void const *                   pNext_         = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , bindingCount{ bindingCount_ }
      , pBindingFlags{ pBindingFlags_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetLayoutBindingFlagsCreateInfo( VkDescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetLayoutBindingFlagsCreateInfo( *reinterpret_cast<DescriptorSetLayoutBindingFlagsCreateInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetLayoutBindingFlagsCreateInfo( ArrayProxyNoTemporaries<DescriptorBindingFlags const> const & bindingFlags_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), bindingCount( static_cast<uint32_t>( bindingFlags_.size() ) ), pBindingFlags( bindingFlags_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DescriptorSetLayoutBindingFlagsCreateInfo & operator=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetLayoutBindingFlagsCreateInfo & operator=( VkDescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetLayoutBindingFlagsCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo & setBindingCount( uint32_t bindingCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      bindingCount = bindingCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo && setBindingCount( uint32_t bindingCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      bindingCount = bindingCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo & setPBindingFlags( DescriptorBindingFlags const * pBindingFlags_ ) & VULKAN_HPP_NOEXCEPT
    {
      pBindingFlags = pBindingFlags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo && setPBindingFlags( DescriptorBindingFlags const * pBindingFlags_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pBindingFlags = pBindingFlags_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetLayoutBindingFlagsCreateInfo &
      setBindingFlags( ArrayProxyNoTemporaries<DescriptorBindingFlags const> const & bindingFlags_ ) VULKAN_HPP_NOEXCEPT
    {
      bindingCount  = static_cast<uint32_t>( bindingFlags_.size() );
      pBindingFlags = bindingFlags_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo const *>( this );
    }

    operator VkDescriptorSetLayoutBindingFlagsCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo *>( this );
    }

    operator VkDescriptorSetLayoutBindingFlagsCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo const *>( this );
    }

    operator VkDescriptorSetLayoutBindingFlagsCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, DescriptorBindingFlags const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, bindingCount, pBindingFlags );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const & ) const = default;
#else
    bool operator==( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) && ( pBindingFlags == rhs.pBindingFlags );
#  endif
    }

    bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                  sType         = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo;
    void const *                   pNext         = {};
    uint32_t                       bindingCount  = {};
    DescriptorBindingFlags const * pBindingFlags = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetLayoutBindingFlagsCreateInfo>
  {
    using Type = DescriptorSetLayoutBindingFlagsCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo>
  {
    using Type = DescriptorSetLayoutBindingFlagsCreateInfo;
  };

  using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;

  // wrapper struct for struct VkDescriptorSetLayoutCreateInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateInfo.html
  struct DescriptorSetLayoutCreateInfo
  {
    using NativeType = VkDescriptorSetLayoutCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorSetLayoutCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags     flags_        = {},
                                                        uint32_t                           bindingCount_ = {},
                                                        DescriptorSetLayoutBinding const * pBindings_    = {},
                                                        void const *                       pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , bindingCount{ bindingCount_ }
      , pBindings{ pBindings_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetLayoutCreateInfo( *reinterpret_cast<DescriptorSetLayoutCreateInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags                                    flags_,
                                   ArrayProxyNoTemporaries<DescriptorSetLayoutBinding const> const & bindings_,
                                   void const *                                                      pNext_ = nullptr )
      : pNext( pNext_ ), flags( flags_ ), bindingCount( static_cast<uint32_t>( bindings_.size() ) ), pBindings( bindings_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DescriptorSetLayoutCreateInfo & operator=( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetLayoutCreateInfo & operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetLayoutCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setFlags( DescriptorSetLayoutCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setFlags( DescriptorSetLayoutCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setBindingCount( uint32_t bindingCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      bindingCount = bindingCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setBindingCount( uint32_t bindingCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      bindingCount = bindingCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setPBindings( DescriptorSetLayoutBinding const * pBindings_ ) & VULKAN_HPP_NOEXCEPT
    {
      pBindings = pBindings_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setPBindings( DescriptorSetLayoutBinding const * pBindings_ ) && VULKAN_HPP_NOEXCEPT
    {
      pBindings = pBindings_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetLayoutCreateInfo & setBindings( ArrayProxyNoTemporaries<DescriptorSetLayoutBinding const> const & bindings_ ) VULKAN_HPP_NOEXCEPT
    {
      bindingCount = static_cast<uint32_t>( bindings_.size() );
      pBindings    = bindings_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo const *>( this );
    }

    operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>( this );
    }

    operator VkDescriptorSetLayoutCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutCreateInfo const *>( this );
    }

    operator VkDescriptorSetLayoutCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::
      tuple<StructureType const &, void const * const &, DescriptorSetLayoutCreateFlags const &, uint32_t const &, DescriptorSetLayoutBinding const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, bindingCount, pBindings );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorSetLayoutCreateInfo const & ) const = default;
#else
    bool operator==( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( bindingCount == rhs.bindingCount ) &&
             ( pBindings == rhs.pBindings );
#  endif
    }

    bool operator!=( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                      sType        = StructureType::eDescriptorSetLayoutCreateInfo;
    void const *                       pNext        = {};
    DescriptorSetLayoutCreateFlags     flags        = {};
    uint32_t                           bindingCount = {};
    DescriptorSetLayoutBinding const * pBindings    = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetLayoutCreateInfo>
  {
    using Type = DescriptorSetLayoutCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorSetLayoutCreateInfo>
  {
    using Type = DescriptorSetLayoutCreateInfo;
  };

  // wrapper struct for struct VkDescriptorSetLayoutHostMappingInfoVALVE, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutHostMappingInfoVALVE.html
  struct DescriptorSetLayoutHostMappingInfoVALVE
  {
    using NativeType = VkDescriptorSetLayoutHostMappingInfoVALVE;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorSetLayoutHostMappingInfoVALVE;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR
      DescriptorSetLayoutHostMappingInfoVALVE( size_t descriptorOffset_ = {}, uint32_t descriptorSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , descriptorOffset{ descriptorOffset_ }
      , descriptorSize{ descriptorSize_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutHostMappingInfoVALVE( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetLayoutHostMappingInfoVALVE( VkDescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetLayoutHostMappingInfoVALVE( *reinterpret_cast<DescriptorSetLayoutHostMappingInfoVALVE const *>( &rhs ) )
    {
    }

    DescriptorSetLayoutHostMappingInfoVALVE & operator=( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetLayoutHostMappingInfoVALVE & operator=( VkDescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetLayoutHostMappingInfoVALVE const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE & setDescriptorOffset( size_t descriptorOffset_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorOffset = descriptorOffset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE && setDescriptorOffset( size_t descriptorOffset_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorOffset = descriptorOffset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE & setDescriptorSize( uint32_t descriptorSize_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorSize = descriptorSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE && setDescriptorSize( uint32_t descriptorSize_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorSize = descriptorSize_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorSetLayoutHostMappingInfoVALVE const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE const *>( this );
    }

    operator VkDescriptorSetLayoutHostMappingInfoVALVE &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( this );
    }

    operator VkDescriptorSetLayoutHostMappingInfoVALVE const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE const *>( this );
    }

    operator VkDescriptorSetLayoutHostMappingInfoVALVE *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, size_t const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, descriptorOffset, descriptorSize );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorSetLayoutHostMappingInfoVALVE const & ) const = default;
#else
    bool operator==( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorOffset == rhs.descriptorOffset ) && ( descriptorSize == rhs.descriptorSize );
#  endif
    }

    bool operator!=( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType            = StructureType::eDescriptorSetLayoutHostMappingInfoVALVE;
    void *        pNext            = {};
    size_t        descriptorOffset = {};
    uint32_t      descriptorSize   = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetLayoutHostMappingInfoVALVE>
  {
    using Type = DescriptorSetLayoutHostMappingInfoVALVE;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorSetLayoutHostMappingInfoVALVE>
  {
    using Type = DescriptorSetLayoutHostMappingInfoVALVE;
  };

  // wrapper struct for struct VkDescriptorSetLayoutSupport, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutSupport.html
  struct DescriptorSetLayoutSupport
  {
    using NativeType = VkDescriptorSetLayoutSupport;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorSetLayoutSupport;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( Bool32 supported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , supported{ supported_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetLayoutSupport( *reinterpret_cast<DescriptorSetLayoutSupport const *>( &rhs ) )
    {
    }

    DescriptorSetLayoutSupport & operator=( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetLayoutSupport & operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetLayoutSupport const *>( &rhs );
      return *this;
    }

    operator VkDescriptorSetLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutSupport const *>( this );
    }

    operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetLayoutSupport *>( this );
    }

    operator VkDescriptorSetLayoutSupport const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutSupport const *>( this );
    }

    operator VkDescriptorSetLayoutSupport *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetLayoutSupport *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, supported );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorSetLayoutSupport const & ) const = default;
#else
    bool operator==( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported );
#  endif
    }

    bool operator!=( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType     = StructureType::eDescriptorSetLayoutSupport;
    void *        pNext     = {};
    Bool32        supported = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetLayoutSupport>
  {
    using Type = DescriptorSetLayoutSupport;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorSetLayoutSupport>
  {
    using Type = DescriptorSetLayoutSupport;
  };

  using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;

  // wrapper struct for struct VkDescriptorSetVariableDescriptorCountAllocateInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html
  struct DescriptorSetVariableDescriptorCountAllocateInfo
  {
    using NativeType = VkDescriptorSetVariableDescriptorCountAllocateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfo( uint32_t         descriptorSetCount_ = {},
                                                                           uint32_t const * pDescriptorCounts_  = {},
                                                                           void const *     pNext_              = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , descriptorSetCount{ descriptorSetCount_ }
      , pDescriptorCounts{ pDescriptorCounts_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      DescriptorSetVariableDescriptorCountAllocateInfo( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetVariableDescriptorCountAllocateInfo( VkDescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetVariableDescriptorCountAllocateInfo( *reinterpret_cast<DescriptorSetVariableDescriptorCountAllocateInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetVariableDescriptorCountAllocateInfo( ArrayProxyNoTemporaries<uint32_t const> const & descriptorCounts_, void const * pNext_ = nullptr )
      : pNext( pNext_ ), descriptorSetCount( static_cast<uint32_t>( descriptorCounts_.size() ) ), pDescriptorCounts( descriptorCounts_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DescriptorSetVariableDescriptorCountAllocateInfo & operator=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetVariableDescriptorCountAllocateInfo & operator=( VkDescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetVariableDescriptorCountAllocateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorSetCount = descriptorSetCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo && setDescriptorSetCount( uint32_t descriptorSetCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorSetCount = descriptorSetCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo & setPDescriptorCounts( uint32_t const * pDescriptorCounts_ ) & VULKAN_HPP_NOEXCEPT
    {
      pDescriptorCounts = pDescriptorCounts_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo && setPDescriptorCounts( uint32_t const * pDescriptorCounts_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pDescriptorCounts = pDescriptorCounts_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorSetVariableDescriptorCountAllocateInfo &
      setDescriptorCounts( ArrayProxyNoTemporaries<uint32_t const> const & descriptorCounts_ ) VULKAN_HPP_NOEXCEPT
    {
      descriptorSetCount = static_cast<uint32_t>( descriptorCounts_.size() );
      pDescriptorCounts  = descriptorCounts_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo const *>( this );
    }

    operator VkDescriptorSetVariableDescriptorCountAllocateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo *>( this );
    }

    operator VkDescriptorSetVariableDescriptorCountAllocateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo const *>( this );
    }

    operator VkDescriptorSetVariableDescriptorCountAllocateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, uint32_t const &, uint32_t const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const & ) const = default;
#else
    bool operator==( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) &&
             ( pDescriptorCounts == rhs.pDescriptorCounts );
#  endif
    }

    bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType    sType              = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo;
    void const *     pNext              = {};
    uint32_t         descriptorSetCount = {};
    uint32_t const * pDescriptorCounts  = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetVariableDescriptorCountAllocateInfo>
  {
    using Type = DescriptorSetVariableDescriptorCountAllocateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo>
  {
    using Type = DescriptorSetVariableDescriptorCountAllocateInfo;
  };

  using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;

  // wrapper struct for struct VkDescriptorSetVariableDescriptorCountLayoutSupport, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html
  struct DescriptorSetVariableDescriptorCountLayoutSupport
  {
    using NativeType = VkDescriptorSetVariableDescriptorCountLayoutSupport;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupport( uint32_t maxVariableDescriptorCount_ = {},
                                                                            void *   pNext_                      = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , maxVariableDescriptorCount{ maxVariableDescriptorCount_ }
    {
    }

    VULKAN_HPP_CONSTEXPR
      DescriptorSetVariableDescriptorCountLayoutSupport( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorSetVariableDescriptorCountLayoutSupport( VkDescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorSetVariableDescriptorCountLayoutSupport( *reinterpret_cast<DescriptorSetVariableDescriptorCountLayoutSupport const *>( &rhs ) )
    {
    }

    DescriptorSetVariableDescriptorCountLayoutSupport &
      operator=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorSetVariableDescriptorCountLayoutSupport & operator=( VkDescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorSetVariableDescriptorCountLayoutSupport const *>( &rhs );
      return *this;
    }

    operator VkDescriptorSetVariableDescriptorCountLayoutSupport const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport const *>( this );
    }

    operator VkDescriptorSetVariableDescriptorCountLayoutSupport &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport *>( this );
    }

    operator VkDescriptorSetVariableDescriptorCountLayoutSupport const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport const *>( this );
    }

    operator VkDescriptorSetVariableDescriptorCountLayoutSupport *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void * const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, maxVariableDescriptorCount );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const & ) const = default;
#else
    bool operator==( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount );
#  endif
    }

    bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType sType                      = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport;
    void *        pNext                      = {};
    uint32_t      maxVariableDescriptorCount = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorSetVariableDescriptorCountLayoutSupport>
  {
    using Type = DescriptorSetVariableDescriptorCountLayoutSupport;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport>
  {
    using Type = DescriptorSetVariableDescriptorCountLayoutSupport;
  };

  using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;

  // wrapper struct for struct VkDescriptorUpdateTemplateEntry, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateEntry.html
  struct DescriptorUpdateTemplateEntry
  {
    using NativeType = VkDescriptorUpdateTemplateEntry;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( uint32_t       dstBinding_      = {},
                                                        uint32_t       dstArrayElement_ = {},
                                                        uint32_t       descriptorCount_ = {},
                                                        DescriptorType descriptorType_  = DescriptorType::eSampler,
                                                        size_t         offset_          = {},
                                                        size_t         stride_          = {} ) VULKAN_HPP_NOEXCEPT
      : dstBinding{ dstBinding_ }
      , dstArrayElement{ dstArrayElement_ }
      , descriptorCount{ descriptorCount_ }
      , descriptorType{ descriptorType_ }
      , offset{ offset_ }
      , stride{ stride_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorUpdateTemplateEntry( *reinterpret_cast<DescriptorUpdateTemplateEntry const *>( &rhs ) )
    {
    }

    DescriptorUpdateTemplateEntry & operator=( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorUpdateTemplateEntry & operator=( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorUpdateTemplateEntry const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDstBinding( uint32_t dstBinding_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstBinding = dstBinding_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDstBinding( uint32_t dstBinding_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstBinding = dstBinding_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDstArrayElement( uint32_t dstArrayElement_ ) & VULKAN_HPP_NOEXCEPT
    {
      dstArrayElement = dstArrayElement_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDstArrayElement( uint32_t dstArrayElement_ ) && VULKAN_HPP_NOEXCEPT
    {
      dstArrayElement = dstArrayElement_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorCount = descriptorCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorCount = descriptorCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorType = descriptorType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorType = descriptorType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setOffset( size_t offset_ ) & VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setOffset( size_t offset_ ) && VULKAN_HPP_NOEXCEPT
    {
      offset = offset_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setStride( size_t stride_ ) & VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setStride( size_t stride_ ) && VULKAN_HPP_NOEXCEPT
    {
      stride = stride_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorUpdateTemplateEntry const *>( this );
    }

    operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorUpdateTemplateEntry *>( this );
    }

    operator VkDescriptorUpdateTemplateEntry const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorUpdateTemplateEntry const *>( this );
    }

    operator VkDescriptorUpdateTemplateEntry *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorUpdateTemplateEntry *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, DescriptorType const &, size_t const &, size_t const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( dstBinding, dstArrayElement, descriptorCount, descriptorType, offset, stride );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorUpdateTemplateEntry const & ) const = default;
#else
    bool operator==( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount ) &&
             ( descriptorType == rhs.descriptorType ) && ( offset == rhs.offset ) && ( stride == rhs.stride );
#  endif
    }

    bool operator!=( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    uint32_t       dstBinding      = {};
    uint32_t       dstArrayElement = {};
    uint32_t       descriptorCount = {};
    DescriptorType descriptorType  = DescriptorType::eSampler;
    size_t         offset          = {};
    size_t         stride          = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorUpdateTemplateEntry>
  {
    using Type = DescriptorUpdateTemplateEntry;
  };
#endif
  using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;

  // wrapper struct for struct VkDescriptorUpdateTemplateCreateInfo, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateCreateInfo.html
  struct DescriptorUpdateTemplateCreateInfo
  {
    using NativeType = VkDescriptorUpdateTemplateCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDescriptorUpdateTemplateCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags   flags_                      = {},
                                                             uint32_t                              descriptorUpdateEntryCount_ = {},
                                                             DescriptorUpdateTemplateEntry const * pDescriptorUpdateEntries_   = {},
                                                             DescriptorUpdateTemplateType          templateType_ = DescriptorUpdateTemplateType::eDescriptorSet,
                                                             DescriptorSetLayout                   descriptorSetLayout_ = {},
                                                             PipelineBindPoint                     pipelineBindPoint_   = PipelineBindPoint::eGraphics,
                                                             PipelineLayout                        pipelineLayout_      = {},
                                                             uint32_t                              set_                 = {},
                                                             void const *                          pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , descriptorUpdateEntryCount{ descriptorUpdateEntryCount_ }
      , pDescriptorUpdateEntries{ pDescriptorUpdateEntries_ }
      , templateType{ templateType_ }
      , descriptorSetLayout{ descriptorSetLayout_ }
      , pipelineBindPoint{ pipelineBindPoint_ }
      , pipelineLayout{ pipelineLayout_ }
      , set{ set_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : DescriptorUpdateTemplateCreateInfo( *reinterpret_cast<DescriptorUpdateTemplateCreateInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags                                  flags_,
                                        ArrayProxyNoTemporaries<DescriptorUpdateTemplateEntry const> const & descriptorUpdateEntries_,
                                        DescriptorUpdateTemplateType templateType_        = DescriptorUpdateTemplateType::eDescriptorSet,
                                        DescriptorSetLayout          descriptorSetLayout_ = {},
                                        PipelineBindPoint            pipelineBindPoint_   = PipelineBindPoint::eGraphics,
                                        PipelineLayout               pipelineLayout_      = {},
                                        uint32_t                     set_                 = {},
                                        void const *                 pNext_               = nullptr )
      : pNext( pNext_ )
      , flags( flags_ )
      , descriptorUpdateEntryCount( static_cast<uint32_t>( descriptorUpdateEntries_.size() ) )
      , pDescriptorUpdateEntries( descriptorUpdateEntries_.data() )
      , templateType( templateType_ )
      , descriptorSetLayout( descriptorSetLayout_ )
      , pipelineBindPoint( pipelineBindPoint_ )
      , pipelineLayout( pipelineLayout_ )
      , set( set_ )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DescriptorUpdateTemplateCreateInfo & operator=( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DescriptorUpdateTemplateCreateInfo & operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DescriptorUpdateTemplateCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setFlags( DescriptorUpdateTemplateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setFlags( DescriptorUpdateTemplateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo &
      setPDescriptorUpdateEntries( DescriptorUpdateTemplateEntry const * pDescriptorUpdateEntries_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo &&
      setPDescriptorUpdateEntries( DescriptorUpdateTemplateEntry const * pDescriptorUpdateEntries_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DescriptorUpdateTemplateCreateInfo &
      setDescriptorUpdateEntries( ArrayProxyNoTemporaries<DescriptorUpdateTemplateEntry const> const & descriptorUpdateEntries_ ) VULKAN_HPP_NOEXCEPT
    {
      descriptorUpdateEntryCount = static_cast<uint32_t>( descriptorUpdateEntries_.size() );
      pDescriptorUpdateEntries   = descriptorUpdateEntries_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setTemplateType( DescriptorUpdateTemplateType templateType_ ) & VULKAN_HPP_NOEXCEPT
    {
      templateType = templateType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setTemplateType( DescriptorUpdateTemplateType templateType_ ) && VULKAN_HPP_NOEXCEPT
    {
      templateType = templateType_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      descriptorSetLayout = descriptorSetLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      descriptorSetLayout = descriptorSetLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT
    {
      pipelineBindPoint = pipelineBindPoint_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT
    {
      pipelineBindPoint = pipelineBindPoint_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setPipelineLayout( PipelineLayout pipelineLayout_ ) & VULKAN_HPP_NOEXCEPT
    {
      pipelineLayout = pipelineLayout_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setPipelineLayout( PipelineLayout pipelineLayout_ ) && VULKAN_HPP_NOEXCEPT
    {
      pipelineLayout = pipelineLayout_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT
    {
      set = set_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT
    {
      set = set_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo const *>( this );
    }

    operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo *>( this );
    }

    operator VkDescriptorUpdateTemplateCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo const *>( this );
    }

    operator VkDescriptorUpdateTemplateCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void const * const &,
               DescriptorUpdateTemplateCreateFlags const &,
               uint32_t const &,
               DescriptorUpdateTemplateEntry const * const &,
               DescriptorUpdateTemplateType const &,
               DescriptorSetLayout const &,
               PipelineBindPoint const &,
               PipelineLayout const &,
               uint32_t const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie(
        sType, pNext, flags, descriptorUpdateEntryCount, pDescriptorUpdateEntries, templateType, descriptorSetLayout, pipelineBindPoint, pipelineLayout, set );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DescriptorUpdateTemplateCreateInfo const & ) const = default;
#else
    bool operator==( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) &&
             ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) && ( templateType == rhs.templateType ) &&
             ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipelineLayout == rhs.pipelineLayout ) &&
             ( set == rhs.set );
#  endif
    }

    bool operator!=( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                         sType                      = StructureType::eDescriptorUpdateTemplateCreateInfo;
    void const *                          pNext                      = {};
    DescriptorUpdateTemplateCreateFlags   flags                      = {};
    uint32_t                              descriptorUpdateEntryCount = {};
    DescriptorUpdateTemplateEntry const * pDescriptorUpdateEntries   = {};
    DescriptorUpdateTemplateType          templateType               = DescriptorUpdateTemplateType::eDescriptorSet;
    DescriptorSetLayout                   descriptorSetLayout        = {};
    PipelineBindPoint                     pipelineBindPoint          = PipelineBindPoint::eGraphics;
    PipelineLayout                        pipelineLayout             = {};
    uint32_t                              set                        = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDescriptorUpdateTemplateCreateInfo>
  {
    using Type = DescriptorUpdateTemplateCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDescriptorUpdateTemplateCreateInfo>
  {
    using Type = DescriptorUpdateTemplateCreateInfo;
  };

  using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;

  // wrapper struct for struct VkDeviceAddressBindingCallbackDataEXT, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingCallbackDataEXT.html
  struct DeviceAddressBindingCallbackDataEXT
  {
    using NativeType = VkDeviceAddressBindingCallbackDataEXT;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDeviceAddressBindingCallbackDataEXT;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DeviceAddressBindingCallbackDataEXT( DeviceAddressBindingFlagsEXT flags_       = {},
                                                              DeviceAddress                baseAddress_ = {},
                                                              DeviceSize                   size_        = {},
                                                              DeviceAddressBindingTypeEXT  bindingType_ = DeviceAddressBindingTypeEXT::eBind,
                                                              void *                       pNext_       = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , baseAddress{ baseAddress_ }
      , size{ size_ }
      , bindingType{ bindingType_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DeviceAddressBindingCallbackDataEXT( DeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DeviceAddressBindingCallbackDataEXT( VkDeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
      : DeviceAddressBindingCallbackDataEXT( *reinterpret_cast<DeviceAddressBindingCallbackDataEXT const *>( &rhs ) )
    {
    }

    DeviceAddressBindingCallbackDataEXT & operator=( DeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DeviceAddressBindingCallbackDataEXT & operator=( VkDeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DeviceAddressBindingCallbackDataEXT const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setFlags( DeviceAddressBindingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setFlags( DeviceAddressBindingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setBaseAddress( DeviceAddress baseAddress_ ) & VULKAN_HPP_NOEXCEPT
    {
      baseAddress = baseAddress_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setBaseAddress( DeviceAddress baseAddress_ ) && VULKAN_HPP_NOEXCEPT
    {
      baseAddress = baseAddress_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT
    {
      size = size_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setBindingType( DeviceAddressBindingTypeEXT bindingType_ ) & VULKAN_HPP_NOEXCEPT
    {
      bindingType = bindingType_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setBindingType( DeviceAddressBindingTypeEXT bindingType_ ) && VULKAN_HPP_NOEXCEPT
    {
      bindingType = bindingType_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDeviceAddressBindingCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT const *>( this );
    }

    operator VkDeviceAddressBindingCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT *>( this );
    }

    operator VkDeviceAddressBindingCallbackDataEXT const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT const *>( this );
    }

    operator VkDeviceAddressBindingCallbackDataEXT *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &,
               void * const &,
               DeviceAddressBindingFlagsEXT const &,
               DeviceAddress const &,
               DeviceSize const &,
               DeviceAddressBindingTypeEXT const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, baseAddress, size, bindingType );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DeviceAddressBindingCallbackDataEXT const & ) const = default;
#else
    bool operator==( DeviceAddressBindingCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( baseAddress == rhs.baseAddress ) && ( size == rhs.size ) &&
             ( bindingType == rhs.bindingType );
#  endif
    }

    bool operator!=( DeviceAddressBindingCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType                sType       = StructureType::eDeviceAddressBindingCallbackDataEXT;
    void *                       pNext       = {};
    DeviceAddressBindingFlagsEXT flags       = {};
    DeviceAddress                baseAddress = {};
    DeviceSize                   size        = {};
    DeviceAddressBindingTypeEXT  bindingType = DeviceAddressBindingTypeEXT::eBind;
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDeviceAddressBindingCallbackDataEXT>
  {
    using Type = DeviceAddressBindingCallbackDataEXT;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDeviceAddressBindingCallbackDataEXT>
  {
    using Type = DeviceAddressBindingCallbackDataEXT;
  };

  // wrapper struct for struct VkDeviceBufferMemoryRequirements, see
  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceBufferMemoryRequirements.html
  struct DeviceBufferMemoryRequirements
  {
    using NativeType = VkDeviceBufferMemoryRequirements;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDeviceBufferMemoryRequirements;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DeviceBufferMemoryRequirements( BufferCreateInfo const * pCreateInfo_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , pCreateInfo{ pCreateInfo_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DeviceBufferMemoryRequirements( DeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DeviceBufferMemoryRequirements( VkDeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
      : DeviceBufferMemoryRequirements( *reinterpret_cast<DeviceBufferMemoryRequirements const *>( &rhs ) )
    {
    }

    DeviceBufferMemoryRequirements & operator=( DeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DeviceBufferMemoryRequirements & operator=( VkDeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DeviceBufferMemoryRequirements const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements & setPCreateInfo( BufferCreateInfo const * pCreateInfo_ ) & VULKAN_HPP_NOEXCEPT
    {
      pCreateInfo = pCreateInfo_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements && setPCreateInfo( BufferCreateInfo const * pCreateInfo_ ) && VULKAN_HPP_NOEXCEPT
    {
      pCreateInfo = pCreateInfo_;
      return std::move( *this );
    }
#endif /*VULKAN_HPP_NO_SETTERS*/

    operator VkDeviceBufferMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceBufferMemoryRequirements const *>( this );
    }

    operator VkDeviceBufferMemoryRequirements &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceBufferMemoryRequirements *>( this );
    }

    operator VkDeviceBufferMemoryRequirements const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceBufferMemoryRequirements const *>( this );
    }

    operator VkDeviceBufferMemoryRequirements *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceBufferMemoryRequirements *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, BufferCreateInfo const * const &> reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, pCreateInfo );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DeviceBufferMemoryRequirements const & ) const = default;
#else
    bool operator==( DeviceBufferMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo );
#  endif
    }

    bool operator!=( DeviceBufferMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType            sType       = StructureType::eDeviceBufferMemoryRequirements;
    void const *             pNext       = {};
    BufferCreateInfo const * pCreateInfo = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDeviceBufferMemoryRequirements>
  {
    using Type = DeviceBufferMemoryRequirements;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDeviceBufferMemoryRequirements>
  {
    using Type = DeviceBufferMemoryRequirements;
  };

  using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;

  // wrapper struct for struct VkDeviceQueueCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateInfo.html
  struct DeviceQueueCreateInfo
  {
    using NativeType = VkDeviceQueueCreateInfo;

    static bool const                                  allowDuplicate = false;
    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDeviceQueueCreateInfo;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_            = {},
                                                uint32_t               queueFamilyIndex_ = {},
                                                uint32_t               queueCount_       = {},
                                                float const *          pQueuePriorities_ = {},
                                                void const *           pNext_            = nullptr ) VULKAN_HPP_NOEXCEPT
      : pNext{ pNext_ }
      , flags{ flags_ }
      , queueFamilyIndex{ queueFamilyIndex_ }
      , queueCount{ queueCount_ }
      , pQueuePriorities{ pQueuePriorities_ }
    {
    }

    VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
      : DeviceQueueCreateInfo( *reinterpret_cast<DeviceQueueCreateInfo const *>( &rhs ) )
    {
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DeviceQueueCreateInfo( DeviceQueueCreateFlags                       flags_,
                           uint32_t                                     queueFamilyIndex_,
                           ArrayProxyNoTemporaries<float const> const & queuePriorities_,
                           void const *                                 pNext_ = nullptr )
      : pNext( pNext_ )
      , flags( flags_ )
      , queueFamilyIndex( queueFamilyIndex_ )
      , queueCount( static_cast<uint32_t>( queuePriorities_.size() ) )
      , pQueuePriorities( queuePriorities_.data() )
    {
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

    DeviceQueueCreateInfo & operator=( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    DeviceQueueCreateInfo & operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<DeviceQueueCreateInfo const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
    {
      pNext = pNext_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setFlags( DeviceQueueCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setFlags( DeviceQueueCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT
    {
      flags = flags_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT
    {
      queueFamilyIndex = queueFamilyIndex_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT
    {
      queueFamilyIndex = queueFamilyIndex_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setQueueCount( uint32_t queueCount_ ) & VULKAN_HPP_NOEXCEPT
    {
      queueCount = queueCount_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setQueueCount( uint32_t queueCount_ ) && VULKAN_HPP_NOEXCEPT
    {
      queueCount = queueCount_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setPQueuePriorities( float const * pQueuePriorities_ ) & VULKAN_HPP_NOEXCEPT
    {
      pQueuePriorities = pQueuePriorities_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setPQueuePriorities( float const * pQueuePriorities_ ) && VULKAN_HPP_NOEXCEPT
    {
      pQueuePriorities = pQueuePriorities_;
      return std::move( *this );
    }

#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
    DeviceQueueCreateInfo & setQueuePriorities( ArrayProxyNoTemporaries<float const> const & queuePriorities_ ) VULKAN_HPP_NOEXCEPT
    {
      queueCount       = static_cast<uint32_t>( queuePriorities_.size() );
      pQueuePriorities = queuePriorities_.data();
      return *this;
    }
#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif   /*VULKAN_HPP_NO_SETTERS*/

    operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceQueueCreateInfo const *>( this );
    }

    operator VkDeviceQueueCreateInfo &() VULKAN_HPP_NOEXCEPT
    {
      return *reinterpret_cast<VkDeviceQueueCreateInfo *>( this );
    }

    operator VkDeviceQueueCreateInfo const *() const VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceQueueCreateInfo const *>( this );
    }

    operator VkDeviceQueueCreateInfo *() VULKAN_HPP_NOEXCEPT
    {
      return reinterpret_cast<VkDeviceQueueCreateInfo *>( this );
    }

#if defined( VULKAN_HPP_USE_REFLECT )
    std::tuple<StructureType const &, void const * const &, DeviceQueueCreateFlags const &, uint32_t const &, uint32_t const &, float const * const &>
      reflect() const VULKAN_HPP_NOEXCEPT
    {
      return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities );
    }
#endif

#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
    auto operator<=>( DeviceQueueCreateInfo const & ) const = default;
#else
    bool operator==( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
#  if defined( VULKAN_HPP_USE_REFLECT )
      return this->reflect() == rhs.reflect();
#  else
      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
             ( queueCount == rhs.queueCount ) && ( pQueuePriorities == rhs.pQueuePriorities );
#  endif
    }

    bool operator!=( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
    {
      return !operator==( rhs );
    }
#endif

  public:
    StructureType          sType            = StructureType::eDeviceQueueCreateInfo;
    void const *           pNext            = {};
    DeviceQueueCreateFlags flags            = {};
    uint32_t               queueFamilyIndex = {};
    uint32_t               queueCount       = {};
    float const *          pQueuePriorities = {};
  };

#if 20 <= VULKAN_HPP_CPP_VERSION
  template <>
  struct CppType<VkDeviceQueueCreateInfo>
  {
    using Type = DeviceQueueCreateInfo;
  };
#endif

  template <>
  struct CppType<StructureType, StructureType::eDeviceQueueCreateInfo>
  {
    using Type = DeviceQueueCreateInfo;
  };

  // wrapper struct for struct VkPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFeatures.html
  struct PhysicalDeviceFeatures
  {
    using NativeType = VkPhysicalDeviceFeatures;

#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
    VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( Bool32 robustBufferAccess_                      = {},
                                                 Bool32 fullDrawIndexUint32_                     = {},
                                                 Bool32 imageCubeArray_                          = {},
                                                 Bool32 independentBlend_                        = {},
                                                 Bool32 geometryShader_                          = {},
                                                 Bool32 tessellationShader_                      = {},
                                                 Bool32 sampleRateShading_                       = {},
                                                 Bool32 dualSrcBlend_                            = {},
                                                 Bool32 logicOp_                                 = {},
                                                 Bool32 multiDrawIndirect_                       = {},
                                                 Bool32 drawIndirectFirstInstance_               = {},
                                                 Bool32 depthClamp_                              = {},
                                                 Bool32 depthBiasClamp_                          = {},
                                                 Bool32 fillModeNonSolid_                        = {},
                                                 Bool32 depthBounds_                             = {},
                                                 Bool32 wideLines_                               = {},
                                                 Bool32 largePoints_                             = {},
                                                 Bool32 alphaToOne_                              = {},
                                                 Bool32 multiViewport_                           = {},
                                                 Bool32 samplerAnisotropy_                       = {},
                                                 Bool32 textureCompressionETC2_                  = {},
                                                 Bool32 textureCompressionASTC_LDR_              = {},
                                                 Bool32 textureCompressionBC_                    = {},
                                                 Bool32 occlusionQueryPrecise_                   = {},
                                                 Bool32 pipelineStatisticsQuery_                 = {},
                                                 Bool32 vertexPipelineStoresAndAtomics_          = {},
                                                 Bool32 fragmentStoresAndAtomics_                = {},
                                                 Bool32 shaderTessellationAndGeometryPointSize_  = {},
                                                 Bool32 shaderImageGatherExtended_               = {},
                                                 Bool32 shaderStorageImageExtendedFormats_       = {},
                                                 Bool32 shaderStorageImageMultisample_           = {},
                                                 Bool32 shaderStorageImageReadWithoutFormat_     = {},
                                                 Bool32 shaderStorageImageWriteWithoutFormat_    = {},
                                                 Bool32 shaderUniformBufferArrayDynamicIndexing_ = {},
                                                 Bool32 shaderSampledImageArrayDynamicIndexing_  = {},
                                                 Bool32 shaderStorageBufferArrayDynamicIndexing_ = {},
                                                 Bool32 shaderStorageImageArrayDynamicIndexing_  = {},
                                                 Bool32 shaderClipDistance_                      = {},
                                                 Bool32 shaderCullDistance_                      = {},
                                                 Bool32 shaderFloat64_                           = {},
                                                 Bool32 shaderInt64_                             = {},
                                                 Bool32 shaderInt16_                             = {},
                                                 Bool32 shaderResourceResidency_                 = {},
                                                 Bool32 shaderResourceMinLod_                    = {},
                                                 Bool32 sparseBinding_                           = {},
                                                 Bool32 sparseResidencyBuffer_                   = {},
                                                 Bool32 sparseResidencyImage2D_                  = {},
                                                 Bool32 sparseResidencyImage3D_                  = {},
                                                 Bool32 sparseResidency2Samples_                 = {},
                                                 Bool32 sparseResidency4Samples_                 = {},
                                                 Bool32 sparseResidency8Samples_                 = {},
                                                 Bool32 sparseResidency16Samples_                = {},
                                                 Bool32 sparseResidencyAliased_                  = {},
                                                 Bool32 variableMultisampleRate_                 = {},
                                                 Bool32 inheritedQueries_                        = {} ) VULKAN_HPP_NOEXCEPT
      : robustBufferAccess{ robustBufferAccess_ }
      , fullDrawIndexUint32{ fullDrawIndexUint32_ }
      , imageCubeArray{ imageCubeArray_ }
      , independentBlend{ independentBlend_ }
      , geometryShader{ geometryShader_ }
      , tessellationShader{ tessellationShader_ }
      , sampleRateShading{ sampleRateShading_ }
      , dualSrcBlend{ dualSrcBlend_ }
      , logicOp{ logicOp_ }
      , multiDrawIndirect{ multiDrawIndirect_ }
      , drawIndirectFirstInstance{ drawIndirectFirstInstance_ }
      , depthClamp{ depthClamp_ }
      , depthBiasClamp{ depthBiasClamp_ }
      , fillModeNonSolid{ fillModeNonSolid_ }
      , depthBounds{ depthBounds_ }
      , wideLines{ wideLines_ }
      , largePoints{ largePoints_ }
      , alphaToOne{ alphaToOne_ }
      , multiViewport{ multiViewport_ }
      , samplerAnisotropy{ samplerAnisotropy_ }
      , textureCompressionETC2{ textureCompressionETC2_ }
      , textureCompressionASTC_LDR{ textureCompressionASTC_LDR_ }
      , textureCompressionBC{ textureCompressionBC_ }
      , occlusionQueryPrecise{ occlusionQueryPrecise_ }
      , pipelineStatisticsQuery{ pipelineStatisticsQuery_ }
      , vertexPipelineStoresAndAtomics{ vertexPipelineStoresAndAtomics_ }
      , fragmentStoresAndAtomics{ fragmentStoresAndAtomics_ }
      , shaderTessellationAndGeometryPointSize{ shaderTessellationAndGeometryPointSize_ }
      , shaderImageGatherExtended{ shaderImageGatherExtended_ }
      , shaderStorageImageExtendedFormats{ shaderStorageImageExtendedFormats_ }
      , shaderStorageImageMultisample{ shaderStorageImageMultisample_ }
      , shaderStorageImageReadWithoutFormat{ shaderStorageImageReadWithoutFormat_ }
      , shaderStorageImageWriteWithoutFormat{ shaderStorageImageWriteWithoutFormat_ }
      , shaderUniformBufferArrayDynamicIndexing{ shaderUniformBufferArrayDynamicIndexing_ }
      , shaderSampledImageArrayDynamicIndexing{ shaderSampledImageArrayDynamicIndexing_ }
      , shaderStorageBufferArrayDynamicIndexing{ shaderStorageBufferArrayDynamicIndexing_ }
      , shaderStorageImageArrayDynamicIndexing{ shaderStorageImageArrayDynamicIndexing_ }
      , shaderClipDistance{ shaderClipDistance_ }
      , shaderCullDistance{ shaderCullDistance_ }
      , shaderFloat64{ shaderFloat64_ }
      , shaderInt64{ shaderInt64_ }
      , shaderInt16{ shaderInt16_ }
      , shaderResourceResidency{ shaderResourceResidency_ }
      , shaderResourceMinLod{ shaderResourceMinLod_ }
      , sparseBinding{ sparseBinding_ }
      , sparseResidencyBuffer{ sparseResidencyBuffer_ }
      , sparseResidencyImage2D{ sparseResidencyImage2D_ }
      , sparseResidencyImage3D{ sparseResidencyImage3D_ }
      , sparseResidency2Samples{ sparseResidency2Samples_ }
      , sparseResidency4Samples{ sparseResidency4Samples_ }
      , sparseResidency8Samples{ sparseResidency8Samples_ }
      , sparseResidency16Samples{ sparseResidency16Samples_ }
      , sparseResidencyAliased{ sparseResidencyAliased_ }
      , variableMultisampleRate{ variableMultisampleRate_ }
      , inheritedQueries{ inheritedQueries_ }
    {
    }

    VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( PhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;

    PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
      : PhysicalDeviceFeatures( *reinterpret_cast<PhysicalDeviceFeatures const *>( &rhs ) )
    {
    }

    PhysicalDeviceFeatures & operator=( PhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/

    PhysicalDeviceFeatures & operator=( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
    {
      *this = *reinterpret_cast<PhysicalDeviceFeatures const *>( &rhs );
      return *this;
    }

#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setRobustBufferAccess( Bool32 robustBufferAccess_ ) & VULKAN_HPP_NOEXCEPT
    {
      robustBufferAccess = robustBufferAccess_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setRobustBufferAccess( Bool32 robustBufferAccess_ ) && VULKAN_HPP_NOEXCEPT
    {
      robustBufferAccess = robustBufferAccess_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ ) & VULKAN_HPP_NOEXCEPT
    {
      fullDrawIndexUint32 = fullDrawIndexUint32_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ ) && VULKAN_HPP_NOEXCEPT
    {
      fullDrawIndexUint32 = fullDrawIndexUint32_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setImageCubeArray( Bool32 imageCubeArray_ ) & VULKAN_HPP_NOEXCEPT
    {
      imageCubeArray = imageCubeArray_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setImageCubeArray( Bool32 imageCubeArray_ ) && VULKAN_HPP_NOEXCEPT
    {
      imageCubeArray = imageCubeArray_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setIndependentBlend( Bool32 independentBlend_ ) & VULKAN_HPP_NOEXCEPT
    {
      independentBlend = independentBlend_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setIndependentBlend( Bool32 independentBlend_ ) && VULKAN_HPP_NOEXCEPT
    {
      independentBlend = independentBlend_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setGeometryShader( Bool32 geometryShader_ ) & VULKAN_HPP_NOEXCEPT
    {
      geometryShader = geometryShader_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setGeometryShader( Bool32 geometryShader_ ) && VULKAN_HPP_NOEXCEPT
    {
      geometryShader = geometryShader_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTessellationShader( Bool32 tessellationShader_ ) & VULKAN_HPP_NOEXCEPT
    {
      tessellationShader = tessellationShader_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTessellationShader( Bool32 tessellationShader_ ) && VULKAN_HPP_NOEXCEPT
    {
      tessellationShader = tessellationShader_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSampleRateShading( Bool32 sampleRateShading_ ) & VULKAN_HPP_NOEXCEPT
    {
      sampleRateShading = sampleRateShading_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSampleRateShading( Bool32 sampleRateShading_ ) && VULKAN_HPP_NOEXCEPT
    {
      sampleRateShading = sampleRateShading_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDualSrcBlend( Bool32 dualSrcBlend_ ) & VULKAN_HPP_NOEXCEPT
    {
      dualSrcBlend = dualSrcBlend_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDualSrcBlend( Bool32 dualSrcBlend_ ) && VULKAN_HPP_NOEXCEPT
    {
      dualSrcBlend = dualSrcBlend_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setLogicOp( Bool32 logicOp_ ) & VULKAN_HPP_NOEXCEPT
    {
      logicOp = logicOp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setLogicOp( Bool32 logicOp_ ) && VULKAN_HPP_NOEXCEPT
    {
      logicOp = logicOp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setMultiDrawIndirect( Bool32 multiDrawIndirect_ ) & VULKAN_HPP_NOEXCEPT
    {
      multiDrawIndirect = multiDrawIndirect_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setMultiDrawIndirect( Bool32 multiDrawIndirect_ ) && VULKAN_HPP_NOEXCEPT
    {
      multiDrawIndirect = multiDrawIndirect_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ ) & VULKAN_HPP_NOEXCEPT
    {
      drawIndirectFirstInstance = drawIndirectFirstInstance_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ ) && VULKAN_HPP_NOEXCEPT
    {
      drawIndirectFirstInstance = drawIndirectFirstInstance_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDepthClamp( Bool32 depthClamp_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthClamp = depthClamp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDepthClamp( Bool32 depthClamp_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthClamp = depthClamp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDepthBiasClamp( Bool32 depthBiasClamp_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthBiasClamp = depthBiasClamp_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDepthBiasClamp( Bool32 depthBiasClamp_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthBiasClamp = depthBiasClamp_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setFillModeNonSolid( Bool32 fillModeNonSolid_ ) & VULKAN_HPP_NOEXCEPT
    {
      fillModeNonSolid = fillModeNonSolid_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setFillModeNonSolid( Bool32 fillModeNonSolid_ ) && VULKAN_HPP_NOEXCEPT
    {
      fillModeNonSolid = fillModeNonSolid_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDepthBounds( Bool32 depthBounds_ ) & VULKAN_HPP_NOEXCEPT
    {
      depthBounds = depthBounds_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDepthBounds( Bool32 depthBounds_ ) && VULKAN_HPP_NOEXCEPT
    {
      depthBounds = depthBounds_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setWideLines( Bool32 wideLines_ ) & VULKAN_HPP_NOEXCEPT
    {
      wideLines = wideLines_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setWideLines( Bool32 wideLines_ ) && VULKAN_HPP_NOEXCEPT
    {
      wideLines = wideLines_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setLargePoints( Bool32 largePoints_ ) & VULKAN_HPP_NOEXCEPT
    {
      largePoints = largePoints_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setLargePoints( Bool32 largePoints_ ) && VULKAN_HPP_NOEXCEPT
    {
      largePoints = largePoints_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setAlphaToOne( Bool32 alphaToOne_ ) & VULKAN_HPP_NOEXCEPT
    {
      alphaToOne = alphaToOne_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setAlphaToOne( Bool32 alphaToOne_ ) && VULKAN_HPP_NOEXCEPT
    {
      alphaToOne = alphaToOne_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setMultiViewport( Bool32 multiViewport_ ) & VULKAN_HPP_NOEXCEPT
    {
      multiViewport = multiViewport_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setMultiViewport( Bool32 multiViewport_ ) && VULKAN_HPP_NOEXCEPT
    {
      multiViewport = multiViewport_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSamplerAnisotropy( Bool32 samplerAnisotropy_ ) & VULKAN_HPP_NOEXCEPT
    {
      samplerAnisotropy = samplerAnisotropy_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSamplerAnisotropy( Bool32 samplerAnisotropy_ ) && VULKAN_HPP_NOEXCEPT
    {
      samplerAnisotropy = samplerAnisotropy_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTextureCompressionETC2( Bool32 textureCompressionETC2_ ) & VULKAN_HPP_NOEXCEPT
    {
      textureCompressionETC2 = textureCompressionETC2_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTextureCompressionETC2( Bool32 textureCompressionETC2_ ) && VULKAN_HPP_NOEXCEPT
    {
      textureCompressionETC2 = textureCompressionETC2_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ ) & VULKAN_HPP_NOEXCEPT
    {
      textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ ) && VULKAN_HPP_NOEXCEPT
    {
      textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTextureCompressionBC( Bool32 textureCompressionBC_ ) & VULKAN_HPP_NOEXCEPT
    {
      textureCompressionBC = textureCompressionBC_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTextureCompressionBC( Bool32 textureCompressionBC_ ) && VULKAN_HPP_NOEXCEPT
    {
      textureCompressionBC = textureCompressionBC_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ ) & VULKAN_HPP_NOEXCEPT
    {
      occlusionQueryPrecise = occlusionQueryPrecise_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ ) && VULKAN_HPP_NOEXCEPT
    {
      occlusionQueryPrecise = occlusionQueryPrecise_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ ) & VULKAN_HPP_NOEXCEPT
    {
      pipelineStatisticsQuery = pipelineStatisticsQuery_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ ) && VULKAN_HPP_NOEXCEPT
    {
      pipelineStatisticsQuery = pipelineStatisticsQuery_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ ) & VULKAN_HPP_NOEXCEPT
    {
      vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ ) && VULKAN_HPP_NOEXCEPT
    {
      vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ ) & VULKAN_HPP_NOEXCEPT
    {
      fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ ) && VULKAN_HPP_NOEXCEPT
    {
      fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ ) &
      VULKAN_HPP_NOEXCEPT
    {
      shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ ) &&
      VULKAN_HPP_NOEXCEPT
    {
      shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ ) & VULKAN_HPP_NOEXCEPT
    {
      shaderImageGatherExtended = shaderImageGatherExtended_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ ) && VULKAN_HPP_NOEXCEPT
    {
      shaderImageGatherExtended = shaderImageGatherExtended_;
      return std::move( *this );
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ ) & VULKAN_HPP_NOEXCEPT
    {
      shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_;
      return *this;
    }

    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setS