include/vulkan/vulkan_handles.hpp - SwiftShader - Git at Google


            
            // Copyright 2015-2025 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_HANDLES_HPP

            
            #  define VULKAN_HANDLES_HPP


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

            
            // IWYU pragma: private; include "vulkan.hpp"


            namespace VULKAN_HPP_NAMESPACE

            
            {


              //===================================

            
              //=== STRUCT forward declarations ===

            
              //===================================


              //=== VK_VERSION_1_0 ===

            
              struct Extent2D;

            
              struct Extent3D;

            
              struct Offset2D;

            
              struct Offset3D;

            
              struct Rect2D;

            
              struct BaseInStructure;

            
              struct BaseOutStructure;

            
              struct BufferMemoryBarrier;

            
              struct DispatchIndirectCommand;

            
              struct DrawIndexedIndirectCommand;

            
              struct DrawIndirectCommand;

            
              struct ImageMemoryBarrier;

            
              struct MemoryBarrier;

            
              struct PipelineCacheHeaderVersionOne;

            
              struct AllocationCallbacks;

            
              struct ApplicationInfo;

            
              struct FormatProperties;

            
              struct ImageFormatProperties;

            
              struct InstanceCreateInfo;

            
              struct MemoryHeap;

            
              struct MemoryType;

            
              struct PhysicalDeviceFeatures;

            
              struct PhysicalDeviceLimits;

            
              struct PhysicalDeviceMemoryProperties;

            
              struct PhysicalDeviceProperties;

            
              struct PhysicalDeviceSparseProperties;

            
              struct QueueFamilyProperties;

            
              struct DeviceCreateInfo;

            
              struct DeviceQueueCreateInfo;

            
              struct ExtensionProperties;

            
              struct LayerProperties;

            
              struct SubmitInfo;

            
              struct MappedMemoryRange;

            
              struct MemoryAllocateInfo;

            
              struct MemoryRequirements;

            
              struct BindSparseInfo;

            
              struct ImageSubresource;

            
              struct SparseBufferMemoryBindInfo;

            
              struct SparseImageFormatProperties;

            
              struct SparseImageMemoryBind;

            
              struct SparseImageMemoryBindInfo;

            
              struct SparseImageMemoryRequirements;

            
              struct SparseImageOpaqueMemoryBindInfo;

            
              struct SparseMemoryBind;

            
              struct FenceCreateInfo;

            
              struct SemaphoreCreateInfo;

            
              struct EventCreateInfo;

            
              struct QueryPoolCreateInfo;

            
              struct BufferCreateInfo;

            
              struct BufferViewCreateInfo;

            
              struct ImageCreateInfo;

            
              struct SubresourceLayout;

            
              struct ComponentMapping;

            
              struct ImageSubresourceRange;

            
              struct ImageViewCreateInfo;

            
              struct ShaderModuleCreateInfo;

            
              struct PipelineCacheCreateInfo;

            
              struct ComputePipelineCreateInfo;

            
              struct GraphicsPipelineCreateInfo;

            
              struct PipelineColorBlendAttachmentState;

            
              struct PipelineColorBlendStateCreateInfo;

            
              struct PipelineDepthStencilStateCreateInfo;

            
              struct PipelineDynamicStateCreateInfo;

            
              struct PipelineInputAssemblyStateCreateInfo;

            
              struct PipelineMultisampleStateCreateInfo;

            
              struct PipelineRasterizationStateCreateInfo;

            
              struct PipelineShaderStageCreateInfo;

            
              struct PipelineTessellationStateCreateInfo;

            
              struct PipelineVertexInputStateCreateInfo;

            
              struct PipelineViewportStateCreateInfo;

            
              struct SpecializationInfo;

            
              struct SpecializationMapEntry;

            
              struct StencilOpState;

            
              struct VertexInputAttributeDescription;

            
              struct VertexInputBindingDescription;

            
              struct Viewport;

            
              struct PipelineLayoutCreateInfo;

            
              struct PushConstantRange;

            
              struct SamplerCreateInfo;

            
              struct CopyDescriptorSet;

            
              struct DescriptorBufferInfo;

            
              struct DescriptorImageInfo;

            
              struct DescriptorPoolCreateInfo;

            
              struct DescriptorPoolSize;

            
              struct DescriptorSetAllocateInfo;

            
              struct DescriptorSetLayoutBinding;

            
              struct DescriptorSetLayoutCreateInfo;

            
              struct WriteDescriptorSet;

            
              struct AttachmentDescription;

            
              struct AttachmentReference;

            
              struct FramebufferCreateInfo;

            
              struct RenderPassCreateInfo;

            
              struct SubpassDependency;

            
              struct SubpassDescription;

            
              struct CommandPoolCreateInfo;

            
              struct CommandBufferAllocateInfo;

            
              struct CommandBufferBeginInfo;

            
              struct CommandBufferInheritanceInfo;

            
              struct BufferCopy;

            
              struct BufferImageCopy;

            
              struct ClearAttachment;

            
              union ClearColorValue;

            
              struct ClearDepthStencilValue;

            
              struct ClearRect;

            
              union ClearValue;

            
              struct ImageBlit;

            
              struct ImageCopy;

            
              struct ImageResolve;

            
              struct ImageSubresourceLayers;

            
              struct RenderPassBeginInfo;


              //=== VK_VERSION_1_1 ===

            
              struct PhysicalDeviceSubgroupProperties;

            
              struct BindBufferMemoryInfo;

            
              using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;

            
              struct BindImageMemoryInfo;

            
              using BindImageMemoryInfoKHR = BindImageMemoryInfo;

            
              struct PhysicalDevice16BitStorageFeatures;

            
              using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;

            
              struct MemoryDedicatedRequirements;

            
              using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;

            
              struct MemoryDedicatedAllocateInfo;

            
              using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;

            
              struct MemoryAllocateFlagsInfo;

            
              using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;

            
              struct DeviceGroupRenderPassBeginInfo;

            
              using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;

            
              struct DeviceGroupCommandBufferBeginInfo;

            
              using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;

            
              struct DeviceGroupSubmitInfo;

            
              using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;

            
              struct DeviceGroupBindSparseInfo;

            
              using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;

            
              struct BindBufferMemoryDeviceGroupInfo;

            
              using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;

            
              struct BindImageMemoryDeviceGroupInfo;

            
              using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;

            
              struct PhysicalDeviceGroupProperties;

            
              using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;

            
              struct DeviceGroupDeviceCreateInfo;

            
              using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;

            
              struct BufferMemoryRequirementsInfo2;

            
              using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;

            
              struct ImageMemoryRequirementsInfo2;

            
              using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;

            
              struct ImageSparseMemoryRequirementsInfo2;

            
              using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;

            
              struct MemoryRequirements2;

            
              using MemoryRequirements2KHR = MemoryRequirements2;

            
              struct SparseImageMemoryRequirements2;

            
              using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;

            
              struct PhysicalDeviceFeatures2;

            
              using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;

            
              struct PhysicalDeviceProperties2;

            
              using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;

            
              struct FormatProperties2;

            
              using FormatProperties2KHR = FormatProperties2;

            
              struct ImageFormatProperties2;

            
              using ImageFormatProperties2KHR = ImageFormatProperties2;

            
              struct PhysicalDeviceImageFormatInfo2;

            
              using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;

            
              struct QueueFamilyProperties2;

            
              using QueueFamilyProperties2KHR = QueueFamilyProperties2;

            
              struct PhysicalDeviceMemoryProperties2;

            
              using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;

            
              struct SparseImageFormatProperties2;

            
              using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;

            
              struct PhysicalDeviceSparseImageFormatInfo2;

            
              using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;

            
              struct PhysicalDevicePointClippingProperties;

            
              using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;

            
              struct RenderPassInputAttachmentAspectCreateInfo;

            
              using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;

            
              struct InputAttachmentAspectReference;

            
              using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;

            
              struct ImageViewUsageCreateInfo;

            
              using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;

            
              struct PipelineTessellationDomainOriginStateCreateInfo;

            
              using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;

            
              struct RenderPassMultiviewCreateInfo;

            
              using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;

            
              struct PhysicalDeviceMultiviewFeatures;

            
              using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;

            
              struct PhysicalDeviceMultiviewProperties;

            
              using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;

            
              struct PhysicalDeviceVariablePointersFeatures;

            
              using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;

            
              using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;

            
              using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;

            
              struct PhysicalDeviceProtectedMemoryFeatures;

            
              struct PhysicalDeviceProtectedMemoryProperties;

            
              struct DeviceQueueInfo2;

            
              struct ProtectedSubmitInfo;

            
              struct SamplerYcbcrConversionCreateInfo;

            
              using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;

            
              struct SamplerYcbcrConversionInfo;

            
              using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;

            
              struct BindImagePlaneMemoryInfo;

            
              using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;

            
              struct ImagePlaneMemoryRequirementsInfo;

            
              using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;

            
              struct PhysicalDeviceSamplerYcbcrConversionFeatures;

            
              using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;

            
              struct SamplerYcbcrConversionImageFormatProperties;

            
              using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;

            
              struct DescriptorUpdateTemplateEntry;

            
              using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;

            
              struct DescriptorUpdateTemplateCreateInfo;

            
              using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;

            
              struct ExternalMemoryProperties;

            
              using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;

            
              struct PhysicalDeviceExternalImageFormatInfo;

            
              using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;

            
              struct ExternalImageFormatProperties;

            
              using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;

            
              struct PhysicalDeviceExternalBufferInfo;

            
              using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;

            
              struct ExternalBufferProperties;

            
              using ExternalBufferPropertiesKHR = ExternalBufferProperties;

            
              struct PhysicalDeviceIDProperties;

            
              using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;

            
              struct ExternalMemoryImageCreateInfo;

            
              using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;

            
              struct ExternalMemoryBufferCreateInfo;

            
              using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;

            
              struct ExportMemoryAllocateInfo;

            
              using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;

            
              struct PhysicalDeviceExternalFenceInfo;

            
              using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;

            
              struct ExternalFenceProperties;

            
              using ExternalFencePropertiesKHR = ExternalFenceProperties;

            
              struct ExportFenceCreateInfo;

            
              using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;

            
              struct ExportSemaphoreCreateInfo;

            
              using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;

            
              struct PhysicalDeviceExternalSemaphoreInfo;

            
              using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;

            
              struct ExternalSemaphoreProperties;

            
              using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;

            
              struct PhysicalDeviceMaintenance3Properties;

            
              using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;

            
              struct DescriptorSetLayoutSupport;

            
              using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;

            
              struct PhysicalDeviceShaderDrawParametersFeatures;

            
              using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;


              //=== VK_VERSION_1_2 ===

            
              struct PhysicalDeviceVulkan11Features;

            
              struct PhysicalDeviceVulkan11Properties;

            
              struct PhysicalDeviceVulkan12Features;

            
              struct PhysicalDeviceVulkan12Properties;

            
              struct ImageFormatListCreateInfo;

            
              using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;

            
              struct RenderPassCreateInfo2;

            
              using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;

            
              struct AttachmentDescription2;

            
              using AttachmentDescription2KHR = AttachmentDescription2;

            
              struct AttachmentReference2;

            
              using AttachmentReference2KHR = AttachmentReference2;

            
              struct SubpassDescription2;

            
              using SubpassDescription2KHR = SubpassDescription2;

            
              struct SubpassDependency2;

            
              using SubpassDependency2KHR = SubpassDependency2;

            
              struct SubpassBeginInfo;

            
              using SubpassBeginInfoKHR = SubpassBeginInfo;

            
              struct SubpassEndInfo;

            
              using SubpassEndInfoKHR = SubpassEndInfo;

            
              struct PhysicalDevice8BitStorageFeatures;

            
              using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;

            
              struct ConformanceVersion;

            
              using ConformanceVersionKHR = ConformanceVersion;

            
              struct PhysicalDeviceDriverProperties;

            
              using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;

            
              struct PhysicalDeviceShaderAtomicInt64Features;

            
              using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;

            
              struct PhysicalDeviceShaderFloat16Int8Features;

            
              using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;

            
              using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;

            
              struct PhysicalDeviceFloatControlsProperties;

            
              using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;

            
              struct DescriptorSetLayoutBindingFlagsCreateInfo;

            
              using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;

            
              struct PhysicalDeviceDescriptorIndexingFeatures;

            
              using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;

            
              struct PhysicalDeviceDescriptorIndexingProperties;

            
              using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;

            
              struct DescriptorSetVariableDescriptorCountAllocateInfo;

            
              using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;

            
              struct DescriptorSetVariableDescriptorCountLayoutSupport;

            
              using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;

            
              struct SubpassDescriptionDepthStencilResolve;

            
              using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;

            
              struct PhysicalDeviceDepthStencilResolveProperties;

            
              using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;

            
              struct PhysicalDeviceScalarBlockLayoutFeatures;

            
              using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;

            
              struct ImageStencilUsageCreateInfo;

            
              using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;

            
              struct SamplerReductionModeCreateInfo;

            
              using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;

            
              struct PhysicalDeviceSamplerFilterMinmaxProperties;

            
              using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;

            
              struct PhysicalDeviceVulkanMemoryModelFeatures;

            
              using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;

            
              struct PhysicalDeviceImagelessFramebufferFeatures;

            
              using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;

            
              struct FramebufferAttachmentsCreateInfo;

            
              using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;

            
              struct FramebufferAttachmentImageInfo;

            
              using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;

            
              struct RenderPassAttachmentBeginInfo;

            
              using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;

            
              struct PhysicalDeviceUniformBufferStandardLayoutFeatures;

            
              using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;

            
              struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;

            
              using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;

            
              struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;

            
              using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;

            
              struct AttachmentReferenceStencilLayout;

            
              using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;

            
              struct AttachmentDescriptionStencilLayout;

            
              using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;

            
              struct PhysicalDeviceHostQueryResetFeatures;

            
              using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;

            
              struct PhysicalDeviceTimelineSemaphoreFeatures;

            
              using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;

            
              struct PhysicalDeviceTimelineSemaphoreProperties;

            
              using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;

            
              struct SemaphoreTypeCreateInfo;

            
              using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;

            
              struct TimelineSemaphoreSubmitInfo;

            
              using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;

            
              struct SemaphoreWaitInfo;

            
              using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;

            
              struct SemaphoreSignalInfo;

            
              using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;

            
              struct PhysicalDeviceBufferDeviceAddressFeatures;

            
              using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;

            
              struct BufferDeviceAddressInfo;

            
              using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;

            
              using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;

            
              struct BufferOpaqueCaptureAddressCreateInfo;

            
              using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;

            
              struct MemoryOpaqueCaptureAddressAllocateInfo;

            
              using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;

            
              struct DeviceMemoryOpaqueCaptureAddressInfo;

            
              using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;


              //=== VK_VERSION_1_3 ===

            
              struct PhysicalDeviceVulkan13Features;

            
              struct PhysicalDeviceVulkan13Properties;

            
              struct PipelineCreationFeedbackCreateInfo;

            
              using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;

            
              struct PipelineCreationFeedback;

            
              using PipelineCreationFeedbackEXT = PipelineCreationFeedback;

            
              struct PhysicalDeviceShaderTerminateInvocationFeatures;

            
              using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;

            
              struct PhysicalDeviceToolProperties;

            
              using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;

            
              struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;

            
              using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;

            
              struct PhysicalDevicePrivateDataFeatures;

            
              using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;

            
              struct DevicePrivateDataCreateInfo;

            
              using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;

            
              struct PrivateDataSlotCreateInfo;

            
              using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;

            
              struct PhysicalDevicePipelineCreationCacheControlFeatures;

            
              using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;

            
              struct MemoryBarrier2;

            
              using MemoryBarrier2KHR = MemoryBarrier2;

            
              struct BufferMemoryBarrier2;

            
              using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;

            
              struct ImageMemoryBarrier2;

            
              using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;

            
              struct DependencyInfo;

            
              using DependencyInfoKHR = DependencyInfo;

            
              struct SubmitInfo2;

            
              using SubmitInfo2KHR = SubmitInfo2;

            
              struct SemaphoreSubmitInfo;

            
              using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;

            
              struct CommandBufferSubmitInfo;

            
              using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;

            
              struct PhysicalDeviceSynchronization2Features;

            
              using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;

            
              struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;

            
              using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;

            
              struct PhysicalDeviceImageRobustnessFeatures;

            
              using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;

            
              struct CopyBufferInfo2;

            
              using CopyBufferInfo2KHR = CopyBufferInfo2;

            
              struct CopyImageInfo2;

            
              using CopyImageInfo2KHR = CopyImageInfo2;

            
              struct CopyBufferToImageInfo2;

            
              using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;

            
              struct CopyImageToBufferInfo2;

            
              using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;

            
              struct BlitImageInfo2;

            
              using BlitImageInfo2KHR = BlitImageInfo2;

            
              struct ResolveImageInfo2;

            
              using ResolveImageInfo2KHR = ResolveImageInfo2;

            
              struct BufferCopy2;

            
              using BufferCopy2KHR = BufferCopy2;

            
              struct ImageCopy2;

            
              using ImageCopy2KHR = ImageCopy2;

            
              struct ImageBlit2;

            
              using ImageBlit2KHR = ImageBlit2;

            
              struct BufferImageCopy2;

            
              using BufferImageCopy2KHR = BufferImageCopy2;

            
              struct ImageResolve2;

            
              using ImageResolve2KHR = ImageResolve2;

            
              struct PhysicalDeviceSubgroupSizeControlFeatures;

            
              using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;

            
              struct PhysicalDeviceSubgroupSizeControlProperties;

            
              using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;

            
              struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;

            
              using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;

            
              using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;

            
              struct PhysicalDeviceInlineUniformBlockFeatures;

            
              using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;

            
              struct PhysicalDeviceInlineUniformBlockProperties;

            
              using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;

            
              struct WriteDescriptorSetInlineUniformBlock;

            
              using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;

            
              struct DescriptorPoolInlineUniformBlockCreateInfo;

            
              using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;

            
              struct PhysicalDeviceTextureCompressionASTCHDRFeatures;

            
              using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;

            
              struct RenderingInfo;

            
              using RenderingInfoKHR = RenderingInfo;

            
              struct RenderingAttachmentInfo;

            
              using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;

            
              struct PipelineRenderingCreateInfo;

            
              using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;

            
              struct PhysicalDeviceDynamicRenderingFeatures;

            
              using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;

            
              struct CommandBufferInheritanceRenderingInfo;

            
              using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;

            
              struct PhysicalDeviceShaderIntegerDotProductFeatures;

            
              using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;

            
              struct PhysicalDeviceShaderIntegerDotProductProperties;

            
              using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;

            
              struct PhysicalDeviceTexelBufferAlignmentProperties;

            
              using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;

            
              struct FormatProperties3;

            
              using FormatProperties3KHR = FormatProperties3;

            
              struct PhysicalDeviceMaintenance4Features;

            
              using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;

            
              struct PhysicalDeviceMaintenance4Properties;

            
              using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;

            
              struct DeviceBufferMemoryRequirements;

            
              using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;

            
              struct DeviceImageMemoryRequirements;

            
              using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;


              //=== VK_VERSION_1_4 ===

            
              struct PhysicalDeviceVulkan14Features;

            
              struct PhysicalDeviceVulkan14Properties;

            
              struct DeviceQueueGlobalPriorityCreateInfo;

            
              using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo;

            
              using DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo;

            
              struct PhysicalDeviceGlobalPriorityQueryFeatures;

            
              using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures;

            
              using PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures;

            
              struct QueueFamilyGlobalPriorityProperties;

            
              using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties;

            
              using QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties;

            
              struct PhysicalDeviceShaderSubgroupRotateFeatures;

            
              using PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures;

            
              struct PhysicalDeviceShaderFloatControls2Features;

            
              using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features;

            
              struct PhysicalDeviceShaderExpectAssumeFeatures;

            
              using PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures;

            
              struct PhysicalDeviceLineRasterizationFeatures;

            
              using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures;

            
              using PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures;

            
              struct PhysicalDeviceLineRasterizationProperties;

            
              using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties;

            
              using PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties;

            
              struct PipelineRasterizationLineStateCreateInfo;

            
              using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo;

            
              using PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo;

            
              struct PhysicalDeviceVertexAttributeDivisorProperties;

            
              using PhysicalDeviceVertexAttributeDivisorPropertiesKHR = PhysicalDeviceVertexAttributeDivisorProperties;

            
              struct VertexInputBindingDivisorDescription;

            
              using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription;

            
              using VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription;

            
              struct PipelineVertexInputDivisorStateCreateInfo;

            
              using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo;

            
              using PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo;

            
              struct PhysicalDeviceVertexAttributeDivisorFeatures;

            
              using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeatures;

            
              using PhysicalDeviceVertexAttributeDivisorFeaturesKHR = PhysicalDeviceVertexAttributeDivisorFeatures;

            
              struct PhysicalDeviceIndexTypeUint8Features;

            
              using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8Features;

            
              using PhysicalDeviceIndexTypeUint8FeaturesKHR = PhysicalDeviceIndexTypeUint8Features;

            
              struct MemoryMapInfo;

            
              using MemoryMapInfoKHR = MemoryMapInfo;

            
              struct MemoryUnmapInfo;

            
              using MemoryUnmapInfoKHR = MemoryUnmapInfo;

            
              struct PhysicalDeviceMaintenance5Features;

            
              using PhysicalDeviceMaintenance5FeaturesKHR = PhysicalDeviceMaintenance5Features;

            
              struct PhysicalDeviceMaintenance5Properties;

            
              using PhysicalDeviceMaintenance5PropertiesKHR = PhysicalDeviceMaintenance5Properties;

            
              struct RenderingAreaInfo;

            
              using RenderingAreaInfoKHR = RenderingAreaInfo;

            
              struct DeviceImageSubresourceInfo;

            
              using DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo;

            
              struct ImageSubresource2;

            
              using ImageSubresource2EXT = ImageSubresource2;

            
              using ImageSubresource2KHR = ImageSubresource2;

            
              struct SubresourceLayout2;

            
              using SubresourceLayout2EXT = SubresourceLayout2;

            
              using SubresourceLayout2KHR = SubresourceLayout2;

            
              struct PipelineCreateFlags2CreateInfo;

            
              using PipelineCreateFlags2CreateInfoKHR = PipelineCreateFlags2CreateInfo;

            
              struct BufferUsageFlags2CreateInfo;

            
              using BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo;

            
              struct PhysicalDevicePushDescriptorProperties;

            
              using PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties;

            
              struct PhysicalDeviceDynamicRenderingLocalReadFeatures;

            
              using PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = PhysicalDeviceDynamicRenderingLocalReadFeatures;

            
              struct RenderingAttachmentLocationInfo;

            
              using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo;

            
              struct RenderingInputAttachmentIndexInfo;

            
              using RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo;

            
              struct PhysicalDeviceMaintenance6Features;

            
              using PhysicalDeviceMaintenance6FeaturesKHR = PhysicalDeviceMaintenance6Features;

            
              struct PhysicalDeviceMaintenance6Properties;

            
              using PhysicalDeviceMaintenance6PropertiesKHR = PhysicalDeviceMaintenance6Properties;

            
              struct BindMemoryStatus;

            
              using BindMemoryStatusKHR = BindMemoryStatus;

            
              struct BindDescriptorSetsInfo;

            
              using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo;

            
              struct PushConstantsInfo;

            
              using PushConstantsInfoKHR = PushConstantsInfo;

            
              struct PushDescriptorSetInfo;

            
              using PushDescriptorSetInfoKHR = PushDescriptorSetInfo;

            
              struct PushDescriptorSetWithTemplateInfo;

            
              using PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo;

            
              struct PhysicalDevicePipelineProtectedAccessFeatures;

            
              using PhysicalDevicePipelineProtectedAccessFeaturesEXT = PhysicalDevicePipelineProtectedAccessFeatures;

            
              struct PhysicalDevicePipelineRobustnessFeatures;

            
              using PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures;

            
              struct PhysicalDevicePipelineRobustnessProperties;

            
              using PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties;

            
              struct PipelineRobustnessCreateInfo;

            
              using PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo;

            
              struct PhysicalDeviceHostImageCopyFeatures;

            
              using PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures;

            
              struct PhysicalDeviceHostImageCopyProperties;

            
              using PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties;

            
              struct MemoryToImageCopy;

            
              using MemoryToImageCopyEXT = MemoryToImageCopy;

            
              struct ImageToMemoryCopy;

            
              using ImageToMemoryCopyEXT = ImageToMemoryCopy;

            
              struct CopyMemoryToImageInfo;

            
              using CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo;

            
              struct CopyImageToMemoryInfo;

            
              using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo;

            
              struct CopyImageToImageInfo;

            
              using CopyImageToImageInfoEXT = CopyImageToImageInfo;

            
              struct HostImageLayoutTransitionInfo;

            
              using HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo;

            
              struct SubresourceHostMemcpySize;

            
              using SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize;

            
              struct HostImageCopyDevicePerformanceQuery;

            
              using HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery;


              //=== VK_KHR_surface ===

            
              struct SurfaceCapabilitiesKHR;

            
              struct SurfaceFormatKHR;


              //=== VK_KHR_swapchain ===

            
              struct SwapchainCreateInfoKHR;

            
              struct PresentInfoKHR;

            
              struct ImageSwapchainCreateInfoKHR;

            
              struct BindImageMemorySwapchainInfoKHR;

            
              struct AcquireNextImageInfoKHR;

            
              struct DeviceGroupPresentCapabilitiesKHR;

            
              struct DeviceGroupPresentInfoKHR;

            
              struct DeviceGroupSwapchainCreateInfoKHR;


              //=== VK_KHR_display ===

            
              struct DisplayModeCreateInfoKHR;

            
              struct DisplayModeParametersKHR;

            
              struct DisplayModePropertiesKHR;

            
              struct DisplayPlaneCapabilitiesKHR;

            
              struct DisplayPlanePropertiesKHR;

            
              struct DisplayPropertiesKHR;

            
              struct DisplaySurfaceCreateInfoKHR;


              //=== VK_KHR_display_swapchain ===

            
              struct DisplayPresentInfoKHR;


            #if defined( VK_USE_PLATFORM_XLIB_KHR )

            
              //=== VK_KHR_xlib_surface ===

            
              struct XlibSurfaceCreateInfoKHR;

            
            #endif /*VK_USE_PLATFORM_XLIB_KHR*/


            #if defined( VK_USE_PLATFORM_XCB_KHR )

            
              //=== VK_KHR_xcb_surface ===

            
              struct XcbSurfaceCreateInfoKHR;

            
            #endif /*VK_USE_PLATFORM_XCB_KHR*/


            #if defined( VK_USE_PLATFORM_WAYLAND_KHR )

            
              //=== VK_KHR_wayland_surface ===

            
              struct WaylandSurfaceCreateInfoKHR;

            
            #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/


            #if defined( VK_USE_PLATFORM_ANDROID_KHR )

            
              //=== VK_KHR_android_surface ===

            
              struct AndroidSurfaceCreateInfoKHR;

            
            #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_win32_surface ===

            
              struct Win32SurfaceCreateInfoKHR;

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_EXT_debug_report ===

            
              struct DebugReportCallbackCreateInfoEXT;


              //=== VK_AMD_rasterization_order ===

            
              struct PipelineRasterizationStateRasterizationOrderAMD;


              //=== VK_EXT_debug_marker ===

            
              struct DebugMarkerObjectNameInfoEXT;

            
              struct DebugMarkerObjectTagInfoEXT;

            
              struct DebugMarkerMarkerInfoEXT;


              //=== VK_KHR_video_queue ===

            
              struct QueueFamilyQueryResultStatusPropertiesKHR;

            
              struct QueueFamilyVideoPropertiesKHR;

            
              struct VideoProfileInfoKHR;

            
              struct VideoProfileListInfoKHR;

            
              struct VideoCapabilitiesKHR;

            
              struct PhysicalDeviceVideoFormatInfoKHR;

            
              struct VideoFormatPropertiesKHR;

            
              struct VideoPictureResourceInfoKHR;

            
              struct VideoReferenceSlotInfoKHR;

            
              struct VideoSessionMemoryRequirementsKHR;

            
              struct BindVideoSessionMemoryInfoKHR;

            
              struct VideoSessionCreateInfoKHR;

            
              struct VideoSessionParametersCreateInfoKHR;

            
              struct VideoSessionParametersUpdateInfoKHR;

            
              struct VideoBeginCodingInfoKHR;

            
              struct VideoEndCodingInfoKHR;

            
              struct VideoCodingControlInfoKHR;


              //=== VK_KHR_video_decode_queue ===

            
              struct VideoDecodeCapabilitiesKHR;

            
              struct VideoDecodeUsageInfoKHR;

            
              struct VideoDecodeInfoKHR;


              //=== VK_NV_dedicated_allocation ===

            
              struct DedicatedAllocationImageCreateInfoNV;

            
              struct DedicatedAllocationBufferCreateInfoNV;

            
              struct DedicatedAllocationMemoryAllocateInfoNV;


              //=== VK_EXT_transform_feedback ===

            
              struct PhysicalDeviceTransformFeedbackFeaturesEXT;

            
              struct PhysicalDeviceTransformFeedbackPropertiesEXT;

            
              struct PipelineRasterizationStateStreamCreateInfoEXT;


              //=== VK_NVX_binary_import ===

            
              struct CuModuleCreateInfoNVX;

            
              struct CuModuleTexturingModeCreateInfoNVX;

            
              struct CuFunctionCreateInfoNVX;

            
              struct CuLaunchInfoNVX;


              //=== VK_NVX_image_view_handle ===

            
              struct ImageViewHandleInfoNVX;

            
              struct ImageViewAddressPropertiesNVX;


              //=== VK_KHR_video_encode_h264 ===

            
              struct VideoEncodeH264CapabilitiesKHR;

            
              struct VideoEncodeH264QualityLevelPropertiesKHR;

            
              struct VideoEncodeH264SessionCreateInfoKHR;

            
              struct VideoEncodeH264SessionParametersCreateInfoKHR;

            
              struct VideoEncodeH264SessionParametersAddInfoKHR;

            
              struct VideoEncodeH264SessionParametersGetInfoKHR;

            
              struct VideoEncodeH264SessionParametersFeedbackInfoKHR;

            
              struct VideoEncodeH264PictureInfoKHR;

            
              struct VideoEncodeH264DpbSlotInfoKHR;

            
              struct VideoEncodeH264NaluSliceInfoKHR;

            
              struct VideoEncodeH264ProfileInfoKHR;

            
              struct VideoEncodeH264RateControlInfoKHR;

            
              struct VideoEncodeH264RateControlLayerInfoKHR;

            
              struct VideoEncodeH264QpKHR;

            
              struct VideoEncodeH264FrameSizeKHR;

            
              struct VideoEncodeH264GopRemainingFrameInfoKHR;


              //=== VK_KHR_video_encode_h265 ===

            
              struct VideoEncodeH265CapabilitiesKHR;

            
              struct VideoEncodeH265SessionCreateInfoKHR;

            
              struct VideoEncodeH265QualityLevelPropertiesKHR;

            
              struct VideoEncodeH265SessionParametersCreateInfoKHR;

            
              struct VideoEncodeH265SessionParametersAddInfoKHR;

            
              struct VideoEncodeH265SessionParametersGetInfoKHR;

            
              struct VideoEncodeH265SessionParametersFeedbackInfoKHR;

            
              struct VideoEncodeH265PictureInfoKHR;

            
              struct VideoEncodeH265DpbSlotInfoKHR;

            
              struct VideoEncodeH265NaluSliceSegmentInfoKHR;

            
              struct VideoEncodeH265ProfileInfoKHR;

            
              struct VideoEncodeH265RateControlInfoKHR;

            
              struct VideoEncodeH265RateControlLayerInfoKHR;

            
              struct VideoEncodeH265QpKHR;

            
              struct VideoEncodeH265FrameSizeKHR;

            
              struct VideoEncodeH265GopRemainingFrameInfoKHR;


              //=== VK_KHR_video_decode_h264 ===

            
              struct VideoDecodeH264ProfileInfoKHR;

            
              struct VideoDecodeH264CapabilitiesKHR;

            
              struct VideoDecodeH264SessionParametersCreateInfoKHR;

            
              struct VideoDecodeH264SessionParametersAddInfoKHR;

            
              struct VideoDecodeH264PictureInfoKHR;

            
              struct VideoDecodeH264DpbSlotInfoKHR;


              //=== VK_AMD_texture_gather_bias_lod ===

            
              struct TextureLODGatherFormatPropertiesAMD;


              //=== VK_AMD_shader_info ===

            
              struct ShaderResourceUsageAMD;

            
              struct ShaderStatisticsInfoAMD;


            #if defined( VK_USE_PLATFORM_GGP )

            
              //=== VK_GGP_stream_descriptor_surface ===

            
              struct StreamDescriptorSurfaceCreateInfoGGP;

            
            #endif /*VK_USE_PLATFORM_GGP*/


              //=== VK_NV_corner_sampled_image ===

            
              struct PhysicalDeviceCornerSampledImageFeaturesNV;


              //=== VK_NV_external_memory_capabilities ===

            
              struct ExternalImageFormatPropertiesNV;


              //=== VK_NV_external_memory ===

            
              struct ExternalMemoryImageCreateInfoNV;

            
              struct ExportMemoryAllocateInfoNV;


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_NV_external_memory_win32 ===

            
              struct ImportMemoryWin32HandleInfoNV;

            
              struct ExportMemoryWin32HandleInfoNV;

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_NV_win32_keyed_mutex ===

            
              struct Win32KeyedMutexAcquireReleaseInfoNV;

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_EXT_validation_flags ===

            
              struct ValidationFlagsEXT;


            #if defined( VK_USE_PLATFORM_VI_NN )

            
              //=== VK_NN_vi_surface ===

            
              struct ViSurfaceCreateInfoNN;

            
            #endif /*VK_USE_PLATFORM_VI_NN*/


              //=== VK_EXT_astc_decode_mode ===

            
              struct ImageViewASTCDecodeModeEXT;

            
              struct PhysicalDeviceASTCDecodeFeaturesEXT;


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_external_memory_win32 ===

            
              struct ImportMemoryWin32HandleInfoKHR;

            
              struct ExportMemoryWin32HandleInfoKHR;

            
              struct MemoryWin32HandlePropertiesKHR;

            
              struct MemoryGetWin32HandleInfoKHR;

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_KHR_external_memory_fd ===

            
              struct ImportMemoryFdInfoKHR;

            
              struct MemoryFdPropertiesKHR;

            
              struct MemoryGetFdInfoKHR;


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_win32_keyed_mutex ===

            
              struct Win32KeyedMutexAcquireReleaseInfoKHR;

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_external_semaphore_win32 ===

            
              struct ImportSemaphoreWin32HandleInfoKHR;

            
              struct ExportSemaphoreWin32HandleInfoKHR;

            
              struct D3D12FenceSubmitInfoKHR;

            
              struct SemaphoreGetWin32HandleInfoKHR;

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_KHR_external_semaphore_fd ===

            
              struct ImportSemaphoreFdInfoKHR;

            
              struct SemaphoreGetFdInfoKHR;


              //=== VK_EXT_conditional_rendering ===

            
              struct ConditionalRenderingBeginInfoEXT;

            
              struct PhysicalDeviceConditionalRenderingFeaturesEXT;

            
              struct CommandBufferInheritanceConditionalRenderingInfoEXT;


              //=== VK_KHR_incremental_present ===

            
              struct PresentRegionsKHR;

            
              struct PresentRegionKHR;

            
              struct RectLayerKHR;


              //=== VK_NV_clip_space_w_scaling ===

            
              struct ViewportWScalingNV;

            
              struct PipelineViewportWScalingStateCreateInfoNV;


              //=== VK_EXT_display_surface_counter ===

            
              struct SurfaceCapabilities2EXT;


              //=== VK_EXT_display_control ===

            
              struct DisplayPowerInfoEXT;

            
              struct DeviceEventInfoEXT;

            
              struct DisplayEventInfoEXT;

            
              struct SwapchainCounterCreateInfoEXT;


              //=== VK_GOOGLE_display_timing ===

            
              struct RefreshCycleDurationGOOGLE;

            
              struct PastPresentationTimingGOOGLE;

            
              struct PresentTimesInfoGOOGLE;

            
              struct PresentTimeGOOGLE;


              //=== VK_NVX_multiview_per_view_attributes ===

            
              struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;

            
              struct MultiviewPerViewAttributesInfoNVX;


              //=== VK_NV_viewport_swizzle ===

            
              struct ViewportSwizzleNV;

            
              struct PipelineViewportSwizzleStateCreateInfoNV;


              //=== VK_EXT_discard_rectangles ===

            
              struct PhysicalDeviceDiscardRectanglePropertiesEXT;

            
              struct PipelineDiscardRectangleStateCreateInfoEXT;


              //=== VK_EXT_conservative_rasterization ===

            
              struct PhysicalDeviceConservativeRasterizationPropertiesEXT;

            
              struct PipelineRasterizationConservativeStateCreateInfoEXT;


              //=== VK_EXT_depth_clip_enable ===

            
              struct PhysicalDeviceDepthClipEnableFeaturesEXT;

            
              struct PipelineRasterizationDepthClipStateCreateInfoEXT;


              //=== VK_EXT_hdr_metadata ===

            
              struct HdrMetadataEXT;

            
              struct XYColorEXT;


              //=== VK_IMG_relaxed_line_rasterization ===

            
              struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG;


              //=== VK_KHR_shared_presentable_image ===

            
              struct SharedPresentSurfaceCapabilitiesKHR;


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_external_fence_win32 ===

            
              struct ImportFenceWin32HandleInfoKHR;

            
              struct ExportFenceWin32HandleInfoKHR;

            
              struct FenceGetWin32HandleInfoKHR;

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_KHR_external_fence_fd ===

            
              struct ImportFenceFdInfoKHR;

            
              struct FenceGetFdInfoKHR;


              //=== VK_KHR_performance_query ===

            
              struct PhysicalDevicePerformanceQueryFeaturesKHR;

            
              struct PhysicalDevicePerformanceQueryPropertiesKHR;

            
              struct PerformanceCounterKHR;

            
              struct PerformanceCounterDescriptionKHR;

            
              struct QueryPoolPerformanceCreateInfoKHR;

            
              union PerformanceCounterResultKHR;

            
              struct AcquireProfilingLockInfoKHR;

            
              struct PerformanceQuerySubmitInfoKHR;


              //=== VK_KHR_get_surface_capabilities2 ===

            
              struct PhysicalDeviceSurfaceInfo2KHR;

            
              struct SurfaceCapabilities2KHR;

            
              struct SurfaceFormat2KHR;


              //=== VK_KHR_get_display_properties2 ===

            
              struct DisplayProperties2KHR;

            
              struct DisplayPlaneProperties2KHR;

            
              struct DisplayModeProperties2KHR;

            
              struct DisplayPlaneInfo2KHR;

            
              struct DisplayPlaneCapabilities2KHR;


            #if defined( VK_USE_PLATFORM_IOS_MVK )

            
              //=== VK_MVK_ios_surface ===

            
              struct IOSSurfaceCreateInfoMVK;

            
            #endif /*VK_USE_PLATFORM_IOS_MVK*/


            #if defined( VK_USE_PLATFORM_MACOS_MVK )

            
              //=== VK_MVK_macos_surface ===

            
              struct MacOSSurfaceCreateInfoMVK;

            
            #endif /*VK_USE_PLATFORM_MACOS_MVK*/


              //=== VK_EXT_debug_utils ===

            
              struct DebugUtilsLabelEXT;

            
              struct DebugUtilsMessengerCallbackDataEXT;

            
              struct DebugUtilsMessengerCreateInfoEXT;

            
              struct DebugUtilsObjectNameInfoEXT;

            
              struct DebugUtilsObjectTagInfoEXT;


            #if defined( VK_USE_PLATFORM_ANDROID_KHR )

            
              //=== VK_ANDROID_external_memory_android_hardware_buffer ===

            
              struct AndroidHardwareBufferUsageANDROID;

            
              struct AndroidHardwareBufferPropertiesANDROID;

            
              struct AndroidHardwareBufferFormatPropertiesANDROID;

            
              struct ImportAndroidHardwareBufferInfoANDROID;

            
              struct MemoryGetAndroidHardwareBufferInfoANDROID;

            
              struct ExternalFormatANDROID;

            
              struct AndroidHardwareBufferFormatProperties2ANDROID;

            
            #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_AMDX_shader_enqueue ===

            
              struct PhysicalDeviceShaderEnqueueFeaturesAMDX;

            
              struct PhysicalDeviceShaderEnqueuePropertiesAMDX;

            
              struct ExecutionGraphPipelineScratchSizeAMDX;

            
              struct ExecutionGraphPipelineCreateInfoAMDX;

            
              struct DispatchGraphInfoAMDX;

            
              struct DispatchGraphCountInfoAMDX;

            
              struct PipelineShaderStageNodeCreateInfoAMDX;

            
              union DeviceOrHostAddressConstAMDX;

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              //=== VK_AMD_mixed_attachment_samples ===

            
              struct AttachmentSampleCountInfoAMD;

            
              using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;


              //=== VK_KHR_shader_bfloat16 ===

            
              struct PhysicalDeviceShaderBfloat16FeaturesKHR;


              //=== VK_EXT_sample_locations ===

            
              struct SampleLocationEXT;

            
              struct SampleLocationsInfoEXT;

            
              struct AttachmentSampleLocationsEXT;

            
              struct SubpassSampleLocationsEXT;

            
              struct RenderPassSampleLocationsBeginInfoEXT;

            
              struct PipelineSampleLocationsStateCreateInfoEXT;

            
              struct PhysicalDeviceSampleLocationsPropertiesEXT;

            
              struct MultisamplePropertiesEXT;


              //=== VK_EXT_blend_operation_advanced ===

            
              struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;

            
              struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;

            
              struct PipelineColorBlendAdvancedStateCreateInfoEXT;


              //=== VK_NV_fragment_coverage_to_color ===

            
              struct PipelineCoverageToColorStateCreateInfoNV;


              //=== VK_KHR_acceleration_structure ===

            
              union DeviceOrHostAddressKHR;

            
              union DeviceOrHostAddressConstKHR;

            
              struct AccelerationStructureBuildRangeInfoKHR;

            
              struct AabbPositionsKHR;

            
              using AabbPositionsNV = AabbPositionsKHR;

            
              struct AccelerationStructureGeometryTrianglesDataKHR;

            
              struct TransformMatrixKHR;

            
              using TransformMatrixNV = TransformMatrixKHR;

            
              struct AccelerationStructureBuildGeometryInfoKHR;

            
              struct AccelerationStructureGeometryAabbsDataKHR;

            
              struct AccelerationStructureInstanceKHR;

            
              using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;

            
              struct AccelerationStructureGeometryInstancesDataKHR;

            
              union AccelerationStructureGeometryDataKHR;

            
              struct AccelerationStructureGeometryKHR;

            
              struct AccelerationStructureCreateInfoKHR;

            
              struct WriteDescriptorSetAccelerationStructureKHR;

            
              struct PhysicalDeviceAccelerationStructureFeaturesKHR;

            
              struct PhysicalDeviceAccelerationStructurePropertiesKHR;

            
              struct AccelerationStructureDeviceAddressInfoKHR;

            
              struct AccelerationStructureVersionInfoKHR;

            
              struct CopyAccelerationStructureToMemoryInfoKHR;

            
              struct CopyMemoryToAccelerationStructureInfoKHR;

            
              struct CopyAccelerationStructureInfoKHR;

            
              struct AccelerationStructureBuildSizesInfoKHR;


              //=== VK_KHR_ray_tracing_pipeline ===

            
              struct RayTracingShaderGroupCreateInfoKHR;

            
              struct RayTracingPipelineCreateInfoKHR;

            
              struct PhysicalDeviceRayTracingPipelineFeaturesKHR;

            
              struct PhysicalDeviceRayTracingPipelinePropertiesKHR;

            
              struct StridedDeviceAddressRegionKHR;

            
              struct TraceRaysIndirectCommandKHR;

            
              struct RayTracingPipelineInterfaceCreateInfoKHR;


              //=== VK_KHR_ray_query ===

            
              struct PhysicalDeviceRayQueryFeaturesKHR;


              //=== VK_NV_framebuffer_mixed_samples ===

            
              struct PipelineCoverageModulationStateCreateInfoNV;


              //=== VK_NV_shader_sm_builtins ===

            
              struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;

            
              struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;


              //=== VK_EXT_image_drm_format_modifier ===

            
              struct DrmFormatModifierPropertiesListEXT;

            
              struct DrmFormatModifierPropertiesEXT;

            
              struct PhysicalDeviceImageDrmFormatModifierInfoEXT;

            
              struct ImageDrmFormatModifierListCreateInfoEXT;

            
              struct ImageDrmFormatModifierExplicitCreateInfoEXT;

            
              struct ImageDrmFormatModifierPropertiesEXT;

            
              struct DrmFormatModifierPropertiesList2EXT;

            
              struct DrmFormatModifierProperties2EXT;


              //=== VK_EXT_validation_cache ===

            
              struct ValidationCacheCreateInfoEXT;

            
              struct ShaderModuleValidationCacheCreateInfoEXT;


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_KHR_portability_subset ===

            
              struct PhysicalDevicePortabilitySubsetFeaturesKHR;

            
              struct PhysicalDevicePortabilitySubsetPropertiesKHR;

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              //=== VK_NV_shading_rate_image ===

            
              struct ShadingRatePaletteNV;

            
              struct PipelineViewportShadingRateImageStateCreateInfoNV;

            
              struct PhysicalDeviceShadingRateImageFeaturesNV;

            
              struct PhysicalDeviceShadingRateImagePropertiesNV;

            
              struct CoarseSampleLocationNV;

            
              struct CoarseSampleOrderCustomNV;

            
              struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;


              //=== VK_NV_ray_tracing ===

            
              struct RayTracingShaderGroupCreateInfoNV;

            
              struct RayTracingPipelineCreateInfoNV;

            
              struct GeometryTrianglesNV;

            
              struct GeometryAABBNV;

            
              struct GeometryDataNV;

            
              struct GeometryNV;

            
              struct AccelerationStructureInfoNV;

            
              struct AccelerationStructureCreateInfoNV;

            
              struct BindAccelerationStructureMemoryInfoNV;

            
              struct WriteDescriptorSetAccelerationStructureNV;

            
              struct AccelerationStructureMemoryRequirementsInfoNV;

            
              struct PhysicalDeviceRayTracingPropertiesNV;


              //=== VK_NV_representative_fragment_test ===

            
              struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;

            
              struct PipelineRepresentativeFragmentTestStateCreateInfoNV;


              //=== VK_EXT_filter_cubic ===

            
              struct PhysicalDeviceImageViewImageFormatInfoEXT;

            
              struct FilterCubicImageViewImageFormatPropertiesEXT;


              //=== VK_EXT_external_memory_host ===

            
              struct ImportMemoryHostPointerInfoEXT;

            
              struct MemoryHostPointerPropertiesEXT;

            
              struct PhysicalDeviceExternalMemoryHostPropertiesEXT;


              //=== VK_KHR_shader_clock ===

            
              struct PhysicalDeviceShaderClockFeaturesKHR;


              //=== VK_AMD_pipeline_compiler_control ===

            
              struct PipelineCompilerControlCreateInfoAMD;


              //=== VK_AMD_shader_core_properties ===

            
              struct PhysicalDeviceShaderCorePropertiesAMD;


              //=== VK_KHR_video_decode_h265 ===

            
              struct VideoDecodeH265ProfileInfoKHR;

            
              struct VideoDecodeH265CapabilitiesKHR;

            
              struct VideoDecodeH265SessionParametersCreateInfoKHR;

            
              struct VideoDecodeH265SessionParametersAddInfoKHR;

            
              struct VideoDecodeH265PictureInfoKHR;

            
              struct VideoDecodeH265DpbSlotInfoKHR;


              //=== VK_AMD_memory_overallocation_behavior ===

            
              struct DeviceMemoryOverallocationCreateInfoAMD;


              //=== VK_EXT_vertex_attribute_divisor ===

            
              struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;


            #if defined( VK_USE_PLATFORM_GGP )

            
              //=== VK_GGP_frame_token ===

            
              struct PresentFrameTokenGGP;

            
            #endif /*VK_USE_PLATFORM_GGP*/


              //=== VK_NV_mesh_shader ===

            
              struct PhysicalDeviceMeshShaderFeaturesNV;

            
              struct PhysicalDeviceMeshShaderPropertiesNV;

            
              struct DrawMeshTasksIndirectCommandNV;


              //=== VK_NV_shader_image_footprint ===

            
              struct PhysicalDeviceShaderImageFootprintFeaturesNV;


              //=== VK_NV_scissor_exclusive ===

            
              struct PipelineViewportExclusiveScissorStateCreateInfoNV;

            
              struct PhysicalDeviceExclusiveScissorFeaturesNV;


              //=== VK_NV_device_diagnostic_checkpoints ===

            
              struct QueueFamilyCheckpointPropertiesNV;

            
              struct CheckpointDataNV;

            
              struct QueueFamilyCheckpointProperties2NV;

            
              struct CheckpointData2NV;


              //=== VK_INTEL_shader_integer_functions2 ===

            
              struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;


              //=== VK_INTEL_performance_query ===

            
              union PerformanceValueDataINTEL;

            
              struct PerformanceValueINTEL;

            
              struct InitializePerformanceApiInfoINTEL;

            
              struct QueryPoolPerformanceQueryCreateInfoINTEL;

            
              using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;

            
              struct PerformanceMarkerInfoINTEL;

            
              struct PerformanceStreamMarkerInfoINTEL;

            
              struct PerformanceOverrideInfoINTEL;

            
              struct PerformanceConfigurationAcquireInfoINTEL;


              //=== VK_EXT_pci_bus_info ===

            
              struct PhysicalDevicePCIBusInfoPropertiesEXT;


              //=== VK_AMD_display_native_hdr ===

            
              struct DisplayNativeHdrSurfaceCapabilitiesAMD;

            
              struct SwapchainDisplayNativeHdrCreateInfoAMD;


            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_imagepipe_surface ===

            
              struct ImagePipeSurfaceCreateInfoFUCHSIA;

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


            #if defined( VK_USE_PLATFORM_METAL_EXT )

            
              //=== VK_EXT_metal_surface ===

            
              struct MetalSurfaceCreateInfoEXT;

            
            #endif /*VK_USE_PLATFORM_METAL_EXT*/


              //=== VK_EXT_fragment_density_map ===

            
              struct PhysicalDeviceFragmentDensityMapFeaturesEXT;

            
              struct PhysicalDeviceFragmentDensityMapPropertiesEXT;

            
              struct RenderPassFragmentDensityMapCreateInfoEXT;

            
              struct RenderingFragmentDensityMapAttachmentInfoEXT;


              //=== VK_KHR_fragment_shading_rate ===

            
              struct FragmentShadingRateAttachmentInfoKHR;

            
              struct PipelineFragmentShadingRateStateCreateInfoKHR;

            
              struct PhysicalDeviceFragmentShadingRateFeaturesKHR;

            
              struct PhysicalDeviceFragmentShadingRatePropertiesKHR;

            
              struct PhysicalDeviceFragmentShadingRateKHR;

            
              struct RenderingFragmentShadingRateAttachmentInfoKHR;


              //=== VK_AMD_shader_core_properties2 ===

            
              struct PhysicalDeviceShaderCoreProperties2AMD;


              //=== VK_AMD_device_coherent_memory ===

            
              struct PhysicalDeviceCoherentMemoryFeaturesAMD;


              //=== VK_EXT_shader_image_atomic_int64 ===

            
              struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;


              //=== VK_KHR_shader_quad_control ===

            
              struct PhysicalDeviceShaderQuadControlFeaturesKHR;


              //=== VK_EXT_memory_budget ===

            
              struct PhysicalDeviceMemoryBudgetPropertiesEXT;


              //=== VK_EXT_memory_priority ===

            
              struct PhysicalDeviceMemoryPriorityFeaturesEXT;

            
              struct MemoryPriorityAllocateInfoEXT;


              //=== VK_KHR_surface_protected_capabilities ===

            
              struct SurfaceProtectedCapabilitiesKHR;


              //=== VK_NV_dedicated_allocation_image_aliasing ===

            
              struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;


              //=== VK_EXT_buffer_device_address ===

            
              struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;

            
              using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;

            
              struct BufferDeviceAddressCreateInfoEXT;


              //=== VK_EXT_validation_features ===

            
              struct ValidationFeaturesEXT;


              //=== VK_KHR_present_wait ===

            
              struct PhysicalDevicePresentWaitFeaturesKHR;


              //=== VK_NV_cooperative_matrix ===

            
              struct CooperativeMatrixPropertiesNV;

            
              struct PhysicalDeviceCooperativeMatrixFeaturesNV;

            
              struct PhysicalDeviceCooperativeMatrixPropertiesNV;


              //=== VK_NV_coverage_reduction_mode ===

            
              struct PhysicalDeviceCoverageReductionModeFeaturesNV;

            
              struct PipelineCoverageReductionStateCreateInfoNV;

            
              struct FramebufferMixedSamplesCombinationNV;


              //=== VK_EXT_fragment_shader_interlock ===

            
              struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;


              //=== VK_EXT_ycbcr_image_arrays ===

            
              struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;


              //=== VK_EXT_provoking_vertex ===

            
              struct PhysicalDeviceProvokingVertexFeaturesEXT;

            
              struct PhysicalDeviceProvokingVertexPropertiesEXT;

            
              struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_EXT_full_screen_exclusive ===

            
              struct SurfaceFullScreenExclusiveInfoEXT;

            
              struct SurfaceCapabilitiesFullScreenExclusiveEXT;

            
              struct SurfaceFullScreenExclusiveWin32InfoEXT;

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_EXT_headless_surface ===

            
              struct HeadlessSurfaceCreateInfoEXT;


              //=== VK_EXT_shader_atomic_float ===

            
              struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;


              //=== VK_EXT_extended_dynamic_state ===

            
              struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;


              //=== VK_KHR_pipeline_executable_properties ===

            
              struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;

            
              struct PipelineInfoKHR;

            
              using PipelineInfoEXT = PipelineInfoKHR;

            
              struct PipelineExecutablePropertiesKHR;

            
              struct PipelineExecutableInfoKHR;

            
              union PipelineExecutableStatisticValueKHR;

            
              struct PipelineExecutableStatisticKHR;

            
              struct PipelineExecutableInternalRepresentationKHR;


              //=== VK_EXT_map_memory_placed ===

            
              struct PhysicalDeviceMapMemoryPlacedFeaturesEXT;

            
              struct PhysicalDeviceMapMemoryPlacedPropertiesEXT;

            
              struct MemoryMapPlacedInfoEXT;


              //=== VK_EXT_shader_atomic_float2 ===

            
              struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;


              //=== VK_EXT_surface_maintenance1 ===

            
              struct SurfacePresentModeEXT;

            
              struct SurfacePresentScalingCapabilitiesEXT;

            
              struct SurfacePresentModeCompatibilityEXT;


              //=== VK_EXT_swapchain_maintenance1 ===

            
              struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT;

            
              struct SwapchainPresentFenceInfoEXT;

            
              struct SwapchainPresentModesCreateInfoEXT;

            
              struct SwapchainPresentModeInfoEXT;

            
              struct SwapchainPresentScalingCreateInfoEXT;

            
              struct ReleaseSwapchainImagesInfoEXT;


              //=== VK_NV_device_generated_commands ===

            
              struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;

            
              struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;

            
              struct GraphicsShaderGroupCreateInfoNV;

            
              struct GraphicsPipelineShaderGroupsCreateInfoNV;

            
              struct BindShaderGroupIndirectCommandNV;

            
              struct BindIndexBufferIndirectCommandNV;

            
              struct BindVertexBufferIndirectCommandNV;

            
              struct SetStateFlagsIndirectCommandNV;

            
              struct IndirectCommandsStreamNV;

            
              struct IndirectCommandsLayoutTokenNV;

            
              struct IndirectCommandsLayoutCreateInfoNV;

            
              struct GeneratedCommandsInfoNV;

            
              struct GeneratedCommandsMemoryRequirementsInfoNV;


              //=== VK_NV_inherited_viewport_scissor ===

            
              struct PhysicalDeviceInheritedViewportScissorFeaturesNV;

            
              struct CommandBufferInheritanceViewportScissorInfoNV;


              //=== VK_EXT_texel_buffer_alignment ===

            
              struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;


              //=== VK_QCOM_render_pass_transform ===

            
              struct RenderPassTransformBeginInfoQCOM;

            
              struct CommandBufferInheritanceRenderPassTransformInfoQCOM;


              //=== VK_EXT_depth_bias_control ===

            
              struct PhysicalDeviceDepthBiasControlFeaturesEXT;

            
              struct DepthBiasInfoEXT;

            
              struct DepthBiasRepresentationInfoEXT;


              //=== VK_EXT_device_memory_report ===

            
              struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;

            
              struct DeviceDeviceMemoryReportCreateInfoEXT;

            
              struct DeviceMemoryReportCallbackDataEXT;


              //=== VK_EXT_custom_border_color ===

            
              struct SamplerCustomBorderColorCreateInfoEXT;

            
              struct PhysicalDeviceCustomBorderColorPropertiesEXT;

            
              struct PhysicalDeviceCustomBorderColorFeaturesEXT;


              //=== VK_KHR_pipeline_library ===

            
              struct PipelineLibraryCreateInfoKHR;


              //=== VK_NV_present_barrier ===

            
              struct PhysicalDevicePresentBarrierFeaturesNV;

            
              struct SurfaceCapabilitiesPresentBarrierNV;

            
              struct SwapchainPresentBarrierCreateInfoNV;


              //=== VK_KHR_present_id ===

            
              struct PresentIdKHR;

            
              struct PhysicalDevicePresentIdFeaturesKHR;


              //=== VK_KHR_video_encode_queue ===

            
              struct VideoEncodeInfoKHR;

            
              struct VideoEncodeCapabilitiesKHR;

            
              struct QueryPoolVideoEncodeFeedbackCreateInfoKHR;

            
              struct VideoEncodeUsageInfoKHR;

            
              struct VideoEncodeRateControlInfoKHR;

            
              struct VideoEncodeRateControlLayerInfoKHR;

            
              struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR;

            
              struct VideoEncodeQualityLevelPropertiesKHR;

            
              struct VideoEncodeQualityLevelInfoKHR;

            
              struct VideoEncodeSessionParametersGetInfoKHR;

            
              struct VideoEncodeSessionParametersFeedbackInfoKHR;


              //=== VK_NV_device_diagnostics_config ===

            
              struct PhysicalDeviceDiagnosticsConfigFeaturesNV;

            
              struct DeviceDiagnosticsConfigCreateInfoNV;


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_NV_cuda_kernel_launch ===

            
              struct CudaModuleCreateInfoNV;

            
              struct CudaFunctionCreateInfoNV;

            
              struct CudaLaunchInfoNV;

            
              struct PhysicalDeviceCudaKernelLaunchFeaturesNV;

            
              struct PhysicalDeviceCudaKernelLaunchPropertiesNV;

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              //=== VK_QCOM_tile_shading ===

            
              struct PhysicalDeviceTileShadingFeaturesQCOM;

            
              struct PhysicalDeviceTileShadingPropertiesQCOM;

            
              struct RenderPassTileShadingCreateInfoQCOM;

            
              struct PerTileBeginInfoQCOM;

            
              struct PerTileEndInfoQCOM;

            
              struct DispatchTileInfoQCOM;


              //=== VK_NV_low_latency ===

            
              struct QueryLowLatencySupportNV;


            #if defined( VK_USE_PLATFORM_METAL_EXT )

            
              //=== VK_EXT_metal_objects ===

            
              struct ExportMetalObjectCreateInfoEXT;

            
              struct ExportMetalObjectsInfoEXT;

            
              struct ExportMetalDeviceInfoEXT;

            
              struct ExportMetalCommandQueueInfoEXT;

            
              struct ExportMetalBufferInfoEXT;

            
              struct ImportMetalBufferInfoEXT;

            
              struct ExportMetalTextureInfoEXT;

            
              struct ImportMetalTextureInfoEXT;

            
              struct ExportMetalIOSurfaceInfoEXT;

            
              struct ImportMetalIOSurfaceInfoEXT;

            
              struct ExportMetalSharedEventInfoEXT;

            
              struct ImportMetalSharedEventInfoEXT;

            
            #endif /*VK_USE_PLATFORM_METAL_EXT*/


              //=== VK_EXT_descriptor_buffer ===

            
              struct PhysicalDeviceDescriptorBufferPropertiesEXT;

            
              struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;

            
              struct PhysicalDeviceDescriptorBufferFeaturesEXT;

            
              struct DescriptorAddressInfoEXT;

            
              struct DescriptorBufferBindingInfoEXT;

            
              struct DescriptorBufferBindingPushDescriptorBufferHandleEXT;

            
              union DescriptorDataEXT;

            
              struct DescriptorGetInfoEXT;

            
              struct BufferCaptureDescriptorDataInfoEXT;

            
              struct ImageCaptureDescriptorDataInfoEXT;

            
              struct ImageViewCaptureDescriptorDataInfoEXT;

            
              struct SamplerCaptureDescriptorDataInfoEXT;

            
              struct OpaqueCaptureDescriptorDataCreateInfoEXT;

            
              struct AccelerationStructureCaptureDescriptorDataInfoEXT;


              //=== VK_EXT_graphics_pipeline_library ===

            
              struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;

            
              struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;

            
              struct GraphicsPipelineLibraryCreateInfoEXT;


              //=== VK_AMD_shader_early_and_late_fragment_tests ===

            
              struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;


              //=== VK_KHR_fragment_shader_barycentric ===

            
              struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;

            
              using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;

            
              struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;


              //=== VK_KHR_shader_subgroup_uniform_control_flow ===

            
              struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;


              //=== VK_NV_fragment_shading_rate_enums ===

            
              struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;

            
              struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;

            
              struct PipelineFragmentShadingRateEnumStateCreateInfoNV;


              //=== VK_NV_ray_tracing_motion_blur ===

            
              struct AccelerationStructureGeometryMotionTrianglesDataNV;

            
              struct AccelerationStructureMotionInfoNV;

            
              struct AccelerationStructureMotionInstanceNV;

            
              union AccelerationStructureMotionInstanceDataNV;

            
              struct AccelerationStructureMatrixMotionInstanceNV;

            
              struct AccelerationStructureSRTMotionInstanceNV;

            
              struct SRTDataNV;

            
              struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;


              //=== VK_EXT_mesh_shader ===

            
              struct PhysicalDeviceMeshShaderFeaturesEXT;

            
              struct PhysicalDeviceMeshShaderPropertiesEXT;

            
              struct DrawMeshTasksIndirectCommandEXT;


              //=== VK_EXT_ycbcr_2plane_444_formats ===

            
              struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;


              //=== VK_EXT_fragment_density_map2 ===

            
              struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;

            
              struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;


              //=== VK_QCOM_rotated_copy_commands ===

            
              struct CopyCommandTransformInfoQCOM;


              //=== VK_KHR_workgroup_memory_explicit_layout ===

            
              struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;


              //=== VK_EXT_image_compression_control ===

            
              struct PhysicalDeviceImageCompressionControlFeaturesEXT;

            
              struct ImageCompressionControlEXT;

            
              struct ImageCompressionPropertiesEXT;


              //=== VK_EXT_attachment_feedback_loop_layout ===

            
              struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;


              //=== VK_EXT_4444_formats ===

            
              struct PhysicalDevice4444FormatsFeaturesEXT;


              //=== VK_EXT_device_fault ===

            
              struct PhysicalDeviceFaultFeaturesEXT;

            
              struct DeviceFaultCountsEXT;

            
              struct DeviceFaultInfoEXT;

            
              struct DeviceFaultAddressInfoEXT;

            
              struct DeviceFaultVendorInfoEXT;

            
              struct DeviceFaultVendorBinaryHeaderVersionOneEXT;


              //=== VK_EXT_rgba10x6_formats ===

            
              struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;


            #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )

            
              //=== VK_EXT_directfb_surface ===

            
              struct DirectFBSurfaceCreateInfoEXT;

            
            #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/


              //=== VK_EXT_vertex_input_dynamic_state ===

            
              struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;

            
              struct VertexInputBindingDescription2EXT;

            
              struct VertexInputAttributeDescription2EXT;


              //=== VK_EXT_physical_device_drm ===

            
              struct PhysicalDeviceDrmPropertiesEXT;


              //=== VK_EXT_device_address_binding_report ===

            
              struct PhysicalDeviceAddressBindingReportFeaturesEXT;

            
              struct DeviceAddressBindingCallbackDataEXT;


              //=== VK_EXT_depth_clip_control ===

            
              struct PhysicalDeviceDepthClipControlFeaturesEXT;

            
              struct PipelineViewportDepthClipControlCreateInfoEXT;


              //=== VK_EXT_primitive_topology_list_restart ===

            
              struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;


              //=== VK_EXT_present_mode_fifo_latest_ready ===

            
              struct PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT;


            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_external_memory ===

            
              struct ImportMemoryZirconHandleInfoFUCHSIA;

            
              struct MemoryZirconHandlePropertiesFUCHSIA;

            
              struct MemoryGetZirconHandleInfoFUCHSIA;

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_external_semaphore ===

            
              struct ImportSemaphoreZirconHandleInfoFUCHSIA;

            
              struct SemaphoreGetZirconHandleInfoFUCHSIA;

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_buffer_collection ===

            
              struct BufferCollectionCreateInfoFUCHSIA;

            
              struct ImportMemoryBufferCollectionFUCHSIA;

            
              struct BufferCollectionImageCreateInfoFUCHSIA;

            
              struct BufferConstraintsInfoFUCHSIA;

            
              struct BufferCollectionBufferCreateInfoFUCHSIA;

            
              struct BufferCollectionPropertiesFUCHSIA;

            
              struct SysmemColorSpaceFUCHSIA;

            
              struct ImageConstraintsInfoFUCHSIA;

            
              struct ImageFormatConstraintsInfoFUCHSIA;

            
              struct BufferCollectionConstraintsInfoFUCHSIA;

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


              //=== VK_HUAWEI_subpass_shading ===

            
              struct SubpassShadingPipelineCreateInfoHUAWEI;

            
              struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;

            
              struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;


              //=== VK_HUAWEI_invocation_mask ===

            
              struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;


              //=== VK_NV_external_memory_rdma ===

            
              struct MemoryGetRemoteAddressInfoNV;

            
              struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;


              //=== VK_EXT_pipeline_properties ===

            
              struct PipelinePropertiesIdentifierEXT;

            
              struct PhysicalDevicePipelinePropertiesFeaturesEXT;


              //=== VK_EXT_frame_boundary ===

            
              struct PhysicalDeviceFrameBoundaryFeaturesEXT;

            
              struct FrameBoundaryEXT;


              //=== VK_EXT_multisampled_render_to_single_sampled ===

            
              struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;

            
              struct SubpassResolvePerformanceQueryEXT;

            
              struct MultisampledRenderToSingleSampledInfoEXT;


              //=== VK_EXT_extended_dynamic_state2 ===

            
              struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;


            #if defined( VK_USE_PLATFORM_SCREEN_QNX )

            
              //=== VK_QNX_screen_surface ===

            
              struct ScreenSurfaceCreateInfoQNX;

            
            #endif /*VK_USE_PLATFORM_SCREEN_QNX*/


              //=== VK_EXT_color_write_enable ===

            
              struct PhysicalDeviceColorWriteEnableFeaturesEXT;

            
              struct PipelineColorWriteCreateInfoEXT;


              //=== VK_EXT_primitives_generated_query ===

            
              struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;


              //=== VK_KHR_ray_tracing_maintenance1 ===

            
              struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR;

            
              struct TraceRaysIndirectCommand2KHR;


              //=== VK_EXT_image_view_min_lod ===

            
              struct PhysicalDeviceImageViewMinLodFeaturesEXT;

            
              struct ImageViewMinLodCreateInfoEXT;


              //=== VK_EXT_multi_draw ===

            
              struct PhysicalDeviceMultiDrawFeaturesEXT;

            
              struct PhysicalDeviceMultiDrawPropertiesEXT;

            
              struct MultiDrawInfoEXT;

            
              struct MultiDrawIndexedInfoEXT;


              //=== VK_EXT_image_2d_view_of_3d ===

            
              struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;


              //=== VK_EXT_shader_tile_image ===

            
              struct PhysicalDeviceShaderTileImageFeaturesEXT;

            
              struct PhysicalDeviceShaderTileImagePropertiesEXT;


              //=== VK_EXT_opacity_micromap ===

            
              struct MicromapBuildInfoEXT;

            
              struct MicromapUsageEXT;

            
              struct MicromapCreateInfoEXT;

            
              struct PhysicalDeviceOpacityMicromapFeaturesEXT;

            
              struct PhysicalDeviceOpacityMicromapPropertiesEXT;

            
              struct MicromapVersionInfoEXT;

            
              struct CopyMicromapToMemoryInfoEXT;

            
              struct CopyMemoryToMicromapInfoEXT;

            
              struct CopyMicromapInfoEXT;

            
              struct MicromapBuildSizesInfoEXT;

            
              struct AccelerationStructureTrianglesOpacityMicromapEXT;

            
              struct MicromapTriangleEXT;


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_NV_displacement_micromap ===

            
              struct PhysicalDeviceDisplacementMicromapFeaturesNV;

            
              struct PhysicalDeviceDisplacementMicromapPropertiesNV;

            
              struct AccelerationStructureTrianglesDisplacementMicromapNV;

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              //=== VK_HUAWEI_cluster_culling_shader ===

            
              struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;

            
              struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;

            
              struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI;


              //=== VK_EXT_border_color_swizzle ===

            
              struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;

            
              struct SamplerBorderColorComponentMappingCreateInfoEXT;


              //=== VK_EXT_pageable_device_local_memory ===

            
              struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;


              //=== VK_ARM_shader_core_properties ===

            
              struct PhysicalDeviceShaderCorePropertiesARM;


              //=== VK_ARM_scheduling_controls ===

            
              struct DeviceQueueShaderCoreControlCreateInfoARM;

            
              struct PhysicalDeviceSchedulingControlsFeaturesARM;

            
              struct PhysicalDeviceSchedulingControlsPropertiesARM;


              //=== VK_EXT_image_sliced_view_of_3d ===

            
              struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;

            
              struct ImageViewSlicedCreateInfoEXT;


              //=== VK_VALVE_descriptor_set_host_mapping ===

            
              struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;

            
              struct DescriptorSetBindingReferenceVALVE;

            
              struct DescriptorSetLayoutHostMappingInfoVALVE;


              //=== VK_EXT_non_seamless_cube_map ===

            
              struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;


              //=== VK_ARM_render_pass_striped ===

            
              struct PhysicalDeviceRenderPassStripedFeaturesARM;

            
              struct PhysicalDeviceRenderPassStripedPropertiesARM;

            
              struct RenderPassStripeBeginInfoARM;

            
              struct RenderPassStripeInfoARM;

            
              struct RenderPassStripeSubmitInfoARM;


              //=== VK_NV_copy_memory_indirect ===

            
              struct CopyMemoryIndirectCommandNV;

            
              struct CopyMemoryToImageIndirectCommandNV;

            
              struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;

            
              struct PhysicalDeviceCopyMemoryIndirectPropertiesNV;


              //=== VK_NV_memory_decompression ===

            
              struct DecompressMemoryRegionNV;

            
              struct PhysicalDeviceMemoryDecompressionFeaturesNV;

            
              struct PhysicalDeviceMemoryDecompressionPropertiesNV;


              //=== VK_NV_device_generated_commands_compute ===

            
              struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;

            
              struct ComputePipelineIndirectBufferInfoNV;

            
              struct PipelineIndirectDeviceAddressInfoNV;

            
              struct BindPipelineIndirectCommandNV;


              //=== VK_NV_ray_tracing_linear_swept_spheres ===

            
              struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV;

            
              struct AccelerationStructureGeometryLinearSweptSpheresDataNV;

            
              struct AccelerationStructureGeometrySpheresDataNV;


              //=== VK_NV_linear_color_attachment ===

            
              struct PhysicalDeviceLinearColorAttachmentFeaturesNV;


              //=== VK_KHR_shader_maximal_reconvergence ===

            
              struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;


              //=== VK_EXT_image_compression_control_swapchain ===

            
              struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;


              //=== VK_QCOM_image_processing ===

            
              struct ImageViewSampleWeightCreateInfoQCOM;

            
              struct PhysicalDeviceImageProcessingFeaturesQCOM;

            
              struct PhysicalDeviceImageProcessingPropertiesQCOM;


              //=== VK_EXT_nested_command_buffer ===

            
              struct PhysicalDeviceNestedCommandBufferFeaturesEXT;

            
              struct PhysicalDeviceNestedCommandBufferPropertiesEXT;


              //=== VK_EXT_external_memory_acquire_unmodified ===

            
              struct ExternalMemoryAcquireUnmodifiedEXT;


              //=== VK_EXT_extended_dynamic_state3 ===

            
              struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;

            
              struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;

            
              struct ColorBlendEquationEXT;

            
              struct ColorBlendAdvancedEXT;


              //=== VK_EXT_subpass_merge_feedback ===

            
              struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;

            
              struct RenderPassCreationControlEXT;

            
              struct RenderPassCreationFeedbackInfoEXT;

            
              struct RenderPassCreationFeedbackCreateInfoEXT;

            
              struct RenderPassSubpassFeedbackInfoEXT;

            
              struct RenderPassSubpassFeedbackCreateInfoEXT;


              //=== VK_LUNARG_direct_driver_loading ===

            
              struct DirectDriverLoadingInfoLUNARG;

            
              struct DirectDriverLoadingListLUNARG;


              //=== VK_ARM_tensors ===

            
              struct TensorDescriptionARM;

            
              struct TensorCreateInfoARM;

            
              struct TensorViewCreateInfoARM;

            
              struct TensorMemoryRequirementsInfoARM;

            
              struct BindTensorMemoryInfoARM;

            
              struct WriteDescriptorSetTensorARM;

            
              struct TensorFormatPropertiesARM;

            
              struct PhysicalDeviceTensorPropertiesARM;

            
              struct TensorMemoryBarrierARM;

            
              struct TensorDependencyInfoARM;

            
              struct PhysicalDeviceTensorFeaturesARM;

            
              struct DeviceTensorMemoryRequirementsARM;

            
              struct CopyTensorInfoARM;

            
              struct TensorCopyARM;

            
              struct MemoryDedicatedAllocateInfoTensorARM;

            
              struct PhysicalDeviceExternalTensorInfoARM;

            
              struct ExternalTensorPropertiesARM;

            
              struct ExternalMemoryTensorCreateInfoARM;

            
              struct PhysicalDeviceDescriptorBufferTensorFeaturesARM;

            
              struct PhysicalDeviceDescriptorBufferTensorPropertiesARM;

            
              struct DescriptorGetTensorInfoARM;

            
              struct TensorCaptureDescriptorDataInfoARM;

            
              struct TensorViewCaptureDescriptorDataInfoARM;

            
              struct FrameBoundaryTensorsARM;


              //=== VK_EXT_shader_module_identifier ===

            
              struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;

            
              struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;

            
              struct PipelineShaderStageModuleIdentifierCreateInfoEXT;

            
              struct ShaderModuleIdentifierEXT;


              //=== VK_EXT_rasterization_order_attachment_access ===

            
              struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;

            
              using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;


              //=== VK_NV_optical_flow ===

            
              struct PhysicalDeviceOpticalFlowFeaturesNV;

            
              struct PhysicalDeviceOpticalFlowPropertiesNV;

            
              struct OpticalFlowImageFormatInfoNV;

            
              struct OpticalFlowImageFormatPropertiesNV;

            
              struct OpticalFlowSessionCreateInfoNV;

            
              struct OpticalFlowSessionCreatePrivateDataInfoNV;

            
              struct OpticalFlowExecuteInfoNV;


              //=== VK_EXT_legacy_dithering ===

            
              struct PhysicalDeviceLegacyDitheringFeaturesEXT;


            #if defined( VK_USE_PLATFORM_ANDROID_KHR )

            
              //=== VK_ANDROID_external_format_resolve ===

            
              struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;

            
              struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;

            
              struct AndroidHardwareBufferFormatResolvePropertiesANDROID;

            
            #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


              //=== VK_AMD_anti_lag ===

            
              struct PhysicalDeviceAntiLagFeaturesAMD;

            
              struct AntiLagDataAMD;

            
              struct AntiLagPresentationInfoAMD;


              //=== VK_KHR_present_id2 ===

            
              struct SurfaceCapabilitiesPresentId2KHR;

            
              struct PresentId2KHR;

            
              struct PhysicalDevicePresentId2FeaturesKHR;


              //=== VK_KHR_present_wait2 ===

            
              struct SurfaceCapabilitiesPresentWait2KHR;

            
              struct PhysicalDevicePresentWait2FeaturesKHR;

            
              struct PresentWait2InfoKHR;


              //=== VK_KHR_ray_tracing_position_fetch ===

            
              struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR;


              //=== VK_EXT_shader_object ===

            
              struct PhysicalDeviceShaderObjectFeaturesEXT;

            
              struct PhysicalDeviceShaderObjectPropertiesEXT;

            
              struct ShaderCreateInfoEXT;


              //=== VK_KHR_pipeline_binary ===

            
              struct PhysicalDevicePipelineBinaryFeaturesKHR;

            
              struct PhysicalDevicePipelineBinaryPropertiesKHR;

            
              struct DevicePipelineBinaryInternalCacheControlKHR;

            
              struct PipelineBinaryKeyKHR;

            
              struct PipelineBinaryDataKHR;

            
              struct PipelineBinaryKeysAndDataKHR;

            
              struct PipelineBinaryCreateInfoKHR;

            
              struct PipelineBinaryInfoKHR;

            
              struct ReleaseCapturedPipelineDataInfoKHR;

            
              struct PipelineBinaryDataInfoKHR;

            
              struct PipelineCreateInfoKHR;

            
              struct PipelineBinaryHandlesInfoKHR;


              //=== VK_QCOM_tile_properties ===

            
              struct PhysicalDeviceTilePropertiesFeaturesQCOM;

            
              struct TilePropertiesQCOM;


              //=== VK_SEC_amigo_profiling ===

            
              struct PhysicalDeviceAmigoProfilingFeaturesSEC;

            
              struct AmigoProfilingSubmitInfoSEC;


              //=== VK_QCOM_multiview_per_view_viewports ===

            
              struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;


              //=== VK_NV_ray_tracing_invocation_reorder ===

            
              struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;

            
              struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;


              //=== VK_NV_cooperative_vector ===

            
              struct PhysicalDeviceCooperativeVectorPropertiesNV;

            
              struct PhysicalDeviceCooperativeVectorFeaturesNV;

            
              struct CooperativeVectorPropertiesNV;

            
              struct ConvertCooperativeVectorMatrixInfoNV;


              //=== VK_NV_extended_sparse_address_space ===

            
              struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;

            
              struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;


              //=== VK_EXT_mutable_descriptor_type ===

            
              struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;

            
              using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;

            
              struct MutableDescriptorTypeListEXT;

            
              using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;

            
              struct MutableDescriptorTypeCreateInfoEXT;

            
              using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;


              //=== VK_EXT_legacy_vertex_attributes ===

            
              struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT;

            
              struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT;


              //=== VK_EXT_layer_settings ===

            
              struct LayerSettingsCreateInfoEXT;

            
              struct LayerSettingEXT;


              //=== VK_ARM_shader_core_builtins ===

            
              struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;

            
              struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;


              //=== VK_EXT_pipeline_library_group_handles ===

            
              struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;


              //=== VK_EXT_dynamic_rendering_unused_attachments ===

            
              struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;


              //=== VK_NV_low_latency2 ===

            
              struct LatencySleepModeInfoNV;

            
              struct LatencySleepInfoNV;

            
              struct SetLatencyMarkerInfoNV;

            
              struct GetLatencyMarkerInfoNV;

            
              struct LatencyTimingsFrameReportNV;

            
              struct LatencySubmissionPresentIdNV;

            
              struct SwapchainLatencyCreateInfoNV;

            
              struct OutOfBandQueueTypeInfoNV;

            
              struct LatencySurfaceCapabilitiesNV;


              //=== VK_KHR_cooperative_matrix ===

            
              struct CooperativeMatrixPropertiesKHR;

            
              struct PhysicalDeviceCooperativeMatrixFeaturesKHR;

            
              struct PhysicalDeviceCooperativeMatrixPropertiesKHR;


              //=== VK_QCOM_multiview_per_view_render_areas ===

            
              struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;

            
              struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;


              //=== VK_KHR_compute_shader_derivatives ===

            
              struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR;

            
              using PhysicalDeviceComputeShaderDerivativesFeaturesNV = PhysicalDeviceComputeShaderDerivativesFeaturesKHR;

            
              struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR;


              //=== VK_KHR_video_decode_av1 ===

            
              struct VideoDecodeAV1ProfileInfoKHR;

            
              struct VideoDecodeAV1CapabilitiesKHR;

            
              struct VideoDecodeAV1SessionParametersCreateInfoKHR;

            
              struct VideoDecodeAV1PictureInfoKHR;

            
              struct VideoDecodeAV1DpbSlotInfoKHR;


              //=== VK_KHR_video_encode_av1 ===

            
              struct PhysicalDeviceVideoEncodeAV1FeaturesKHR;

            
              struct VideoEncodeAV1CapabilitiesKHR;

            
              struct VideoEncodeAV1QualityLevelPropertiesKHR;

            
              struct VideoEncodeAV1SessionCreateInfoKHR;

            
              struct VideoEncodeAV1SessionParametersCreateInfoKHR;

            
              struct VideoEncodeAV1PictureInfoKHR;

            
              struct VideoEncodeAV1DpbSlotInfoKHR;

            
              struct VideoEncodeAV1ProfileInfoKHR;

            
              struct VideoEncodeAV1QIndexKHR;

            
              struct VideoEncodeAV1FrameSizeKHR;

            
              struct VideoEncodeAV1GopRemainingFrameInfoKHR;

            
              struct VideoEncodeAV1RateControlInfoKHR;

            
              struct VideoEncodeAV1RateControlLayerInfoKHR;


              //=== VK_KHR_video_decode_vp9 ===

            
              struct PhysicalDeviceVideoDecodeVP9FeaturesKHR;

            
              struct VideoDecodeVP9ProfileInfoKHR;

            
              struct VideoDecodeVP9CapabilitiesKHR;

            
              struct VideoDecodeVP9PictureInfoKHR;


              //=== VK_KHR_video_maintenance1 ===

            
              struct PhysicalDeviceVideoMaintenance1FeaturesKHR;

            
              struct VideoInlineQueryInfoKHR;


              //=== VK_NV_per_stage_descriptor_set ===

            
              struct PhysicalDevicePerStageDescriptorSetFeaturesNV;


              //=== VK_QCOM_image_processing2 ===

            
              struct PhysicalDeviceImageProcessing2FeaturesQCOM;

            
              struct PhysicalDeviceImageProcessing2PropertiesQCOM;

            
              struct SamplerBlockMatchWindowCreateInfoQCOM;


              //=== VK_QCOM_filter_cubic_weights ===

            
              struct PhysicalDeviceCubicWeightsFeaturesQCOM;

            
              struct SamplerCubicWeightsCreateInfoQCOM;

            
              struct BlitImageCubicWeightsInfoQCOM;


              //=== VK_QCOM_ycbcr_degamma ===

            
              struct PhysicalDeviceYcbcrDegammaFeaturesQCOM;

            
              struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;


              //=== VK_QCOM_filter_cubic_clamp ===

            
              struct PhysicalDeviceCubicClampFeaturesQCOM;


              //=== VK_EXT_attachment_feedback_loop_dynamic_state ===

            
              struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;


              //=== VK_KHR_unified_image_layouts ===

            
              struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHR;

            
              struct AttachmentFeedbackLoopInfoEXT;


            #if defined( VK_USE_PLATFORM_SCREEN_QNX )

            
              //=== VK_QNX_external_memory_screen_buffer ===

            
              struct ScreenBufferPropertiesQNX;

            
              struct ScreenBufferFormatPropertiesQNX;

            
              struct ImportScreenBufferInfoQNX;

            
              struct ExternalFormatQNX;

            
              struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;

            
            #endif /*VK_USE_PLATFORM_SCREEN_QNX*/


              //=== VK_MSFT_layered_driver ===

            
              struct PhysicalDeviceLayeredDriverPropertiesMSFT;


              //=== VK_KHR_calibrated_timestamps ===

            
              struct CalibratedTimestampInfoKHR;

            
              using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;


              //=== VK_KHR_maintenance6 ===

            
              struct SetDescriptorBufferOffsetsInfoEXT;

            
              struct BindDescriptorBufferEmbeddedSamplersInfoEXT;


              //=== VK_NV_descriptor_pool_overallocation ===

            
              struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;


              //=== VK_QCOM_tile_memory_heap ===

            
              struct PhysicalDeviceTileMemoryHeapFeaturesQCOM;

            
              struct PhysicalDeviceTileMemoryHeapPropertiesQCOM;

            
              struct TileMemoryRequirementsQCOM;

            
              struct TileMemoryBindInfoQCOM;

            
              struct TileMemorySizeInfoQCOM;


              //=== VK_NV_display_stereo ===

            
              struct DisplaySurfaceStereoCreateInfoNV;

            
              struct DisplayModeStereoPropertiesNV;


              //=== VK_KHR_video_encode_quantization_map ===

            
              struct VideoEncodeQuantizationMapCapabilitiesKHR;

            
              struct VideoFormatQuantizationMapPropertiesKHR;

            
              struct VideoEncodeQuantizationMapInfoKHR;

            
              struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR;

            
              struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR;

            
              struct VideoEncodeH264QuantizationMapCapabilitiesKHR;

            
              struct VideoEncodeH265QuantizationMapCapabilitiesKHR;

            
              struct VideoFormatH265QuantizationMapPropertiesKHR;

            
              struct VideoEncodeAV1QuantizationMapCapabilitiesKHR;

            
              struct VideoFormatAV1QuantizationMapPropertiesKHR;


              //=== VK_NV_raw_access_chains ===

            
              struct PhysicalDeviceRawAccessChainsFeaturesNV;


              //=== VK_NV_external_compute_queue ===

            
              struct ExternalComputeQueueDeviceCreateInfoNV;

            
              struct ExternalComputeQueueCreateInfoNV;

            
              struct ExternalComputeQueueDataParamsNV;

            
              struct PhysicalDeviceExternalComputeQueuePropertiesNV;


              //=== VK_KHR_shader_relaxed_extended_instruction ===

            
              struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;


              //=== VK_NV_command_buffer_inheritance ===

            
              struct PhysicalDeviceCommandBufferInheritanceFeaturesNV;


              //=== VK_KHR_maintenance7 ===

            
              struct PhysicalDeviceMaintenance7FeaturesKHR;

            
              struct PhysicalDeviceMaintenance7PropertiesKHR;

            
              struct PhysicalDeviceLayeredApiPropertiesListKHR;

            
              struct PhysicalDeviceLayeredApiPropertiesKHR;

            
              struct PhysicalDeviceLayeredApiVulkanPropertiesKHR;


              //=== VK_NV_shader_atomic_float16_vector ===

            
              struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;


              //=== VK_EXT_shader_replicated_composites ===

            
              struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT;


              //=== VK_EXT_shader_float8 ===

            
              struct PhysicalDeviceShaderFloat8FeaturesEXT;


              //=== VK_NV_ray_tracing_validation ===

            
              struct PhysicalDeviceRayTracingValidationFeaturesNV;


              //=== VK_NV_cluster_acceleration_structure ===

            
              struct PhysicalDeviceClusterAccelerationStructureFeaturesNV;

            
              struct PhysicalDeviceClusterAccelerationStructurePropertiesNV;

            
              struct ClusterAccelerationStructureClustersBottomLevelInputNV;

            
              struct ClusterAccelerationStructureTriangleClusterInputNV;

            
              struct ClusterAccelerationStructureMoveObjectsInputNV;

            
              union ClusterAccelerationStructureOpInputNV;

            
              struct ClusterAccelerationStructureInputInfoNV;

            
              struct ClusterAccelerationStructureCommandsInfoNV;

            
              struct StridedDeviceAddressNV;

            
              struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;

            
              struct ClusterAccelerationStructureMoveObjectsInfoNV;

            
              struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV;

            
              struct ClusterAccelerationStructureBuildTriangleClusterInfoNV;

            
              struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV;

            
              struct ClusterAccelerationStructureInstantiateClusterInfoNV;

            
              struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV;


              //=== VK_NV_partitioned_acceleration_structure ===

            
              struct PhysicalDevicePartitionedAccelerationStructureFeaturesNV;

            
              struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV;

            
              struct PartitionedAccelerationStructureFlagsNV;

            
              struct BuildPartitionedAccelerationStructureIndirectCommandNV;

            
              struct PartitionedAccelerationStructureWriteInstanceDataNV;

            
              struct PartitionedAccelerationStructureUpdateInstanceDataNV;

            
              struct PartitionedAccelerationStructureWritePartitionTranslationDataNV;

            
              struct WriteDescriptorSetPartitionedAccelerationStructureNV;

            
              struct PartitionedAccelerationStructureInstancesInputNV;

            
              struct BuildPartitionedAccelerationStructureInfoNV;


              //=== VK_EXT_device_generated_commands ===

            
              struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT;

            
              struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT;

            
              struct GeneratedCommandsMemoryRequirementsInfoEXT;

            
              struct IndirectExecutionSetCreateInfoEXT;

            
              union IndirectExecutionSetInfoEXT;

            
              struct IndirectExecutionSetPipelineInfoEXT;

            
              struct IndirectExecutionSetShaderInfoEXT;

            
              struct GeneratedCommandsInfoEXT;

            
              struct WriteIndirectExecutionSetPipelineEXT;

            
              struct IndirectCommandsLayoutCreateInfoEXT;

            
              struct IndirectCommandsLayoutTokenEXT;

            
              struct DrawIndirectCountIndirectCommandEXT;

            
              struct IndirectCommandsVertexBufferTokenEXT;

            
              struct BindVertexBufferIndirectCommandEXT;

            
              struct IndirectCommandsIndexBufferTokenEXT;

            
              struct BindIndexBufferIndirectCommandEXT;

            
              struct IndirectCommandsPushConstantTokenEXT;

            
              struct IndirectCommandsExecutionSetTokenEXT;

            
              union IndirectCommandsTokenDataEXT;

            
              struct IndirectExecutionSetShaderLayoutInfoEXT;

            
              struct GeneratedCommandsPipelineInfoEXT;

            
              struct GeneratedCommandsShaderInfoEXT;

            
              struct WriteIndirectExecutionSetShaderEXT;


              //=== VK_KHR_maintenance8 ===

            
              struct PhysicalDeviceMaintenance8FeaturesKHR;

            
              struct MemoryBarrierAccessFlags3KHR;


              //=== VK_MESA_image_alignment_control ===

            
              struct PhysicalDeviceImageAlignmentControlFeaturesMESA;

            
              struct PhysicalDeviceImageAlignmentControlPropertiesMESA;

            
              struct ImageAlignmentControlCreateInfoMESA;


              //=== VK_EXT_depth_clamp_control ===

            
              struct PhysicalDeviceDepthClampControlFeaturesEXT;

            
              struct PipelineViewportDepthClampControlCreateInfoEXT;

            
              struct DepthClampRangeEXT;


              //=== VK_KHR_maintenance9 ===

            
              struct PhysicalDeviceMaintenance9FeaturesKHR;

            
              struct PhysicalDeviceMaintenance9PropertiesKHR;

            
              struct QueueFamilyOwnershipTransferPropertiesKHR;


              //=== VK_KHR_video_maintenance2 ===

            
              struct PhysicalDeviceVideoMaintenance2FeaturesKHR;

            
              struct VideoDecodeH264InlineSessionParametersInfoKHR;

            
              struct VideoDecodeH265InlineSessionParametersInfoKHR;

            
              struct VideoDecodeAV1InlineSessionParametersInfoKHR;


              //=== VK_HUAWEI_hdr_vivid ===

            
              struct PhysicalDeviceHdrVividFeaturesHUAWEI;

            
              struct HdrVividDynamicMetadataHUAWEI;


              //=== VK_NV_cooperative_matrix2 ===

            
              struct CooperativeMatrixFlexibleDimensionsPropertiesNV;

            
              struct PhysicalDeviceCooperativeMatrix2FeaturesNV;

            
              struct PhysicalDeviceCooperativeMatrix2PropertiesNV;


              //=== VK_ARM_pipeline_opacity_micromap ===

            
              struct PhysicalDevicePipelineOpacityMicromapFeaturesARM;


            #if defined( VK_USE_PLATFORM_METAL_EXT )

            
              //=== VK_EXT_external_memory_metal ===

            
              struct ImportMemoryMetalHandleInfoEXT;

            
              struct MemoryMetalHandlePropertiesEXT;

            
              struct MemoryGetMetalHandleInfoEXT;

            
            #endif /*VK_USE_PLATFORM_METAL_EXT*/


              //=== VK_KHR_depth_clamp_zero_one ===

            
              struct PhysicalDeviceDepthClampZeroOneFeaturesKHR;

            
              using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR;


              //=== VK_EXT_vertex_attribute_robustness ===

            
              struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;


              //=== VK_ARM_format_pack ===

            
              struct PhysicalDeviceFormatPackFeaturesARM;


              //=== VK_KHR_robustness2 ===

            
              struct PhysicalDeviceRobustness2FeaturesKHR;

            
              using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR;

            
              struct PhysicalDeviceRobustness2PropertiesKHR;

            
              using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR;


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_NV_present_metering ===

            
              struct SetPresentConfigNV;

            
              struct PhysicalDevicePresentMeteringFeaturesNV;

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              //=== VK_EXT_fragment_density_map_offset ===

            
              struct RenderingEndInfoEXT;

            
              struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;

            
              using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;

            
              struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;

            
              using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;

            
              struct RenderPassFragmentDensityMapOffsetEndInfoEXT;

            
              using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT;


              //=== VK_EXT_zero_initialize_device_memory ===

            
              struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT;


              //===================================

            
              //=== HANDLE forward declarations ===

            
              //===================================


              //=== VK_VERSION_1_0 ===

            
            class Instance;

            
            class PhysicalDevice;

            
            class Device;

            
            class Queue;

            
            class DeviceMemory;

            
            class Fence;

            
            class Semaphore;

            
            class Event;

            
            class QueryPool;

            
            class Buffer;

            
            class BufferView;

            
            class Image;

            
            class ImageView;

            
            class ShaderModule;

            
            class PipelineCache;

            
            class Pipeline;

            
            class PipelineLayout;

            
            class Sampler;

            
            class DescriptorPool;

            
            class DescriptorSet;

            
            class DescriptorSetLayout;

            
            class Framebuffer;

            
            class RenderPass;

            
            class CommandPool;

            
            class CommandBuffer;


              //=== VK_VERSION_1_1 ===

            
            class SamplerYcbcrConversion;

            
            class DescriptorUpdateTemplate;


              //=== VK_VERSION_1_3 ===

            
            class PrivateDataSlot;


              //=== VK_KHR_surface ===

            
            class SurfaceKHR;


              //=== VK_KHR_swapchain ===

            
            class SwapchainKHR;


              //=== VK_KHR_display ===

            
            class DisplayKHR;

            
            class DisplayModeKHR;


              //=== VK_EXT_debug_report ===

            
            class DebugReportCallbackEXT;


              //=== VK_KHR_video_queue ===

            
            class VideoSessionKHR;

            
            class VideoSessionParametersKHR;


              //=== VK_NVX_binary_import ===

            
            class CuModuleNVX;

            
            class CuFunctionNVX;


              //=== VK_EXT_debug_utils ===

            
            class DebugUtilsMessengerEXT;


              //=== VK_KHR_acceleration_structure ===

            
            class AccelerationStructureKHR;


              //=== VK_EXT_validation_cache ===

            
            class ValidationCacheEXT;


              //=== VK_NV_ray_tracing ===

            
            class AccelerationStructureNV;


              //=== VK_INTEL_performance_query ===

            
            class PerformanceConfigurationINTEL;


              //=== VK_KHR_deferred_host_operations ===

            
            class DeferredOperationKHR;


              //=== VK_NV_device_generated_commands ===

            
            class IndirectCommandsLayoutNV;


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_NV_cuda_kernel_launch ===

            
            class CudaModuleNV;

            
            class CudaFunctionNV;

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_buffer_collection ===

            
            class BufferCollectionFUCHSIA;

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


              //=== VK_EXT_opacity_micromap ===

            
            class MicromapEXT;


              //=== VK_ARM_tensors ===

            
            class TensorARM;

            
            class TensorViewARM;


              //=== VK_NV_optical_flow ===

            
            class OpticalFlowSessionNV;


              //=== VK_EXT_shader_object ===

            
            class ShaderEXT;


              //=== VK_KHR_pipeline_binary ===

            
            class PipelineBinaryKHR;


              //=== VK_NV_external_compute_queue ===

            
            class ExternalComputeQueueNV;


              //=== VK_EXT_device_generated_commands ===

            
            class IndirectCommandsLayoutEXT;

            
            class IndirectExecutionSetEXT;


              typedef void (VKAPI_PTR *PFN_VoidFunction)(  );


            #ifndef VULKAN_HPP_NO_SMART_HANDLE

            
              //======================

            
              //=== UNIQUE HANDLEs ===

            
              //======================


              //=== VK_VERSION_1_0 ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Instance, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;

            
              };

            
              using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Device, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;

            
              };

            
              using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<DeviceMemory, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectFree<Device, Dispatch>;

            
              };

            
              using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Fence, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Semaphore, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Event, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<QueryPool, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Buffer, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<BufferView, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Image, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<ImageView, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<ShaderModule, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<PipelineCache, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Pipeline, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<PipelineLayout, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Sampler, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<DescriptorPool, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<DescriptorSet, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::PoolFree<Device, DescriptorPool, Dispatch>;

            
              };

            
              using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<DescriptorSetLayout, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<Framebuffer, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<RenderPass, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<CommandPool, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<CommandBuffer, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::PoolFree<Device, CommandPool, Dispatch>;

            
              };

            
              using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_VERSION_1_1 ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;  template <typename Dispatch>

            
              class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              //=== VK_VERSION_1_3 ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<PrivateDataSlot, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              //=== VK_KHR_surface ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<SurfaceKHR, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Instance, Dispatch>;

            
              };

            
              using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_KHR_swapchain ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<SwapchainKHR, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_KHR_display ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<DisplayKHR, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<PhysicalDevice, Dispatch>;

            
              };

            
              using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_EXT_debug_report ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Instance, Dispatch>;

            
              };

            
              using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_KHR_video_queue ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<VideoSessionKHR, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_NVX_binary_import ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<CuModuleNVX, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<CuFunctionNVX, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_EXT_debug_utils ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Instance, Dispatch>;

            
              };

            
              using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_KHR_acceleration_structure ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_EXT_validation_cache ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<ValidationCacheEXT, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_NV_ray_tracing ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<AccelerationStructureNV, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_INTEL_performance_query ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<PerformanceConfigurationINTEL, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniquePerformanceConfigurationINTEL = UniqueHandle<PerformanceConfigurationINTEL, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_KHR_deferred_host_operations ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<DeferredOperationKHR, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_NV_device_generated_commands ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_NV_cuda_kernel_launch ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<CudaModuleNV, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueCudaModuleNV = UniqueHandle<CudaModuleNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<CudaFunctionNV, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueCudaFunctionNV = UniqueHandle<CudaFunctionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_buffer_collection ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


              //=== VK_EXT_opacity_micromap ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<MicromapEXT, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_ARM_tensors ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<TensorARM, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueTensorARM = UniqueHandle<TensorARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<TensorViewARM, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueTensorViewARM = UniqueHandle<TensorViewARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_NV_optical_flow ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_EXT_shader_object ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<ShaderEXT, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_KHR_pipeline_binary ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<PipelineBinaryKHR, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniquePipelineBinaryKHR = UniqueHandle<PipelineBinaryKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_NV_external_compute_queue ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<ExternalComputeQueueNV, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueExternalComputeQueueNV = UniqueHandle<ExternalComputeQueueNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;


              //=== VK_EXT_device_generated_commands ===

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<IndirectCommandsLayoutEXT, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueIndirectCommandsLayoutEXT = UniqueHandle<IndirectCommandsLayoutEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
              template <typename Dispatch>

            
              class UniqueHandleTraits<IndirectExecutionSetEXT, Dispatch>

            
              {

            
              public:

            
                using deleter = detail::ObjectDestroy<Device, Dispatch>;

            
              };

            
              using UniqueIndirectExecutionSetEXT = UniqueHandle<IndirectExecutionSetEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

            
            #endif  /*VULKAN_HPP_NO_SMART_HANDLE*/


              //===============

            
              //=== HANDLEs ===

            
              //===============


              template <typename Type>

            
              struct isVulkanHandleType

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;

            
              };


              // wrapper class for handle VkSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceKHR.html

            
              class SurfaceKHR

            
              {

            
              public:

            
                using CType = VkSurfaceKHR;

            
                using NativeType = VkSurfaceKHR;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;


              public:

            
                SurfaceKHR() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                SurfaceKHR( SurfaceKHR const & rhs ) = default;

            
                SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                SurfaceKHR( SurfaceKHR && rhs ) = default;

            
                SurfaceKHR & operator=( SurfaceKHR && rhs ) = default;

            
            #else

            
                SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_surfaceKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_surfaceKHR, {} ) )

            
                {}

            
                SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_surfaceKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_surfaceKHR, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT

            
                  : m_surfaceKHR( surfaceKHR )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_surfaceKHR = surfaceKHR;

            
                  return *this;

            
                }

            
            #endif


                SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_surfaceKHR = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_surfaceKHR;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_surfaceKHR != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_surfaceKHR == VK_NULL_HANDLE;

            
                }


              private:

            
                VkSurfaceKHR m_surfaceKHR = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkSurfaceKHR, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackEXT.html

            
              class DebugReportCallbackEXT

            
              {

            
              public:

            
                using CType = VkDebugReportCallbackEXT;

            
                using NativeType = VkDebugReportCallbackEXT;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;


              public:

            
                DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DebugReportCallbackEXT( DebugReportCallbackEXT const & rhs ) = default;

            
                DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) = default;

            
                DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) = default;

            
            #else

            
                DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_debugReportCallbackEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} ) )

            
                {}

            
                DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_debugReportCallbackEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT

            
                  : m_debugReportCallbackEXT( debugReportCallbackEXT )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_debugReportCallbackEXT = debugReportCallbackEXT;

            
                  return *this;

            
                }

            
            #endif


                DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_debugReportCallbackEXT = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_debugReportCallbackEXT;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_debugReportCallbackEXT != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_debugReportCallbackEXT == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDebugReportCallbackEXT, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerEXT.html

            
              class DebugUtilsMessengerEXT

            
              {

            
              public:

            
                using CType = VkDebugUtilsMessengerEXT;

            
                using NativeType = VkDebugUtilsMessengerEXT;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs ) = default;

            
                DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default;

            
                DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default;

            
            #else

            
                DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_debugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} ) )

            
                {}

            
                DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_debugUtilsMessengerEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT

            
                  : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;

            
                  return *this;

            
                }

            
            #endif


                DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_debugUtilsMessengerEXT = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_debugUtilsMessengerEXT;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDebugUtilsMessengerEXT, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDisplayKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayKHR.html

            
              class DisplayKHR

            
              {

            
              public:

            
                using CType = VkDisplayKHR;

            
                using NativeType = VkDisplayKHR;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;


              public:

            
                DisplayKHR() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DisplayKHR( DisplayKHR const & rhs ) = default;

            
                DisplayKHR & operator=( DisplayKHR const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DisplayKHR( DisplayKHR && rhs ) = default;

            
                DisplayKHR & operator=( DisplayKHR && rhs ) = default;

            
            #else

            
                DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_displayKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayKHR, {} ) )

            
                {}

            
                DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_displayKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayKHR, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT

            
                  : m_displayKHR( displayKHR )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DisplayKHR & operator=(VkDisplayKHR displayKHR) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_displayKHR = displayKHR;

            
                  return *this;

            
                }

            
            #endif


                DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_displayKHR = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_displayKHR;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_displayKHR != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_displayKHR == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDisplayKHR m_displayKHR = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDisplayKHR, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainKHR.html

            
              class SwapchainKHR

            
              {

            
              public:

            
                using CType = VkSwapchainKHR;

            
                using NativeType = VkSwapchainKHR;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;


              public:

            
                SwapchainKHR() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                SwapchainKHR( SwapchainKHR const & rhs ) = default;

            
                SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                SwapchainKHR( SwapchainKHR && rhs ) = default;

            
                SwapchainKHR & operator=( SwapchainKHR && rhs ) = default;

            
            #else

            
                SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_swapchainKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchainKHR, {} ) )

            
                {}

            
                SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_swapchainKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchainKHR, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT

            
                  : m_swapchainKHR( swapchainKHR )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_swapchainKHR = swapchainKHR;

            
                  return *this;

            
                }

            
            #endif


                SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_swapchainKHR = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_swapchainKHR;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_swapchainKHR != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_swapchainKHR == VK_NULL_HANDLE;

            
                }


              private:

            
                VkSwapchainKHR m_swapchainKHR = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkSwapchainKHR, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphore.html

            
              class Semaphore

            
              {

            
              public:

            
                using CType = VkSemaphore;

            
                using NativeType = VkSemaphore;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;


              public:

            
                Semaphore() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Semaphore( Semaphore const & rhs ) = default;

            
                Semaphore & operator=( Semaphore const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Semaphore( Semaphore && rhs ) = default;

            
                Semaphore & operator=( Semaphore && rhs ) = default;

            
            #else

            
                Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_semaphore( VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} ) )

            
                {}

            
                Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_semaphore = VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT

            
                  : m_semaphore( semaphore )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                Semaphore & operator=(VkSemaphore semaphore) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_semaphore = semaphore;

            
                  return *this;

            
                }

            
            #endif


                Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_semaphore = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_semaphore;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_semaphore != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_semaphore == VK_NULL_HANDLE;

            
                }


              private:

            
                VkSemaphore m_semaphore = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Semaphore;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Semaphore;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkSemaphore, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Semaphore;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFence.html

            
              class Fence

            
              {

            
              public:

            
                using CType = VkFence;

            
                using NativeType = VkFence;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;


              public:

            
                Fence() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Fence( Fence const & rhs ) = default;

            
                Fence & operator=( Fence const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Fence( Fence && rhs ) = default;

            
                Fence & operator=( Fence && rhs ) = default;

            
            #else

            
                Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_fence( VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} ) )

            
                {}

            
                Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_fence = VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT

            
                  : m_fence( fence )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                Fence & operator=(VkFence fence) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_fence = fence;

            
                  return *this;

            
                }

            
            #endif


                Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_fence = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_fence;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_fence != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_fence == VK_NULL_HANDLE;

            
                }


              private:

            
                VkFence m_fence = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Fence;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Fence;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkFence, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Fence;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkPerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationINTEL.html

            
              class PerformanceConfigurationINTEL

            
              {

            
              public:

            
                using CType = VkPerformanceConfigurationINTEL;

            
                using NativeType = VkPerformanceConfigurationINTEL;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & rhs ) = default;

            
                PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) = default;

            
                PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) = default;

            
            #else

            
                PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_performanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} ) )

            
                {}

            
                PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_performanceConfigurationINTEL = VULKAN_HPP_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT

            
                  : m_performanceConfigurationINTEL( performanceConfigurationINTEL )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                PerformanceConfigurationINTEL & operator=(VkPerformanceConfigurationINTEL performanceConfigurationINTEL) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_performanceConfigurationINTEL = performanceConfigurationINTEL;

            
                  return *this;

            
                }

            
            #endif


                PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_performanceConfigurationINTEL = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_performanceConfigurationINTEL;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_performanceConfigurationINTEL != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_performanceConfigurationINTEL == VK_NULL_HANDLE;

            
                }


              private:

            
                VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkPerformanceConfigurationINTEL, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPool.html

            
              class QueryPool

            
              {

            
              public:

            
                using CType = VkQueryPool;

            
                using NativeType = VkQueryPool;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;


              public:

            
                QueryPool() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                QueryPool( QueryPool const & rhs ) = default;

            
                QueryPool & operator=( QueryPool const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                QueryPool( QueryPool && rhs ) = default;

            
                QueryPool & operator=( QueryPool && rhs ) = default;

            
            #else

            
                QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_queryPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} ) )

            
                {}

            
                QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_queryPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT

            
                  : m_queryPool( queryPool )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                QueryPool & operator=(VkQueryPool queryPool) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_queryPool = queryPool;

            
                  return *this;

            
                }

            
            #endif


                QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_queryPool = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_queryPool;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_queryPool != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_queryPool == VK_NULL_HANDLE;

            
                }


              private:

            
                VkQueryPool m_queryPool = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::QueryPool;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::QueryPool;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkQueryPool, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::QueryPool;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuffer.html

            
              class Buffer

            
              {

            
              public:

            
                using CType = VkBuffer;

            
                using NativeType = VkBuffer;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;


              public:

            
                Buffer() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Buffer( Buffer const & rhs ) = default;

            
                Buffer & operator=( Buffer const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Buffer( Buffer && rhs ) = default;

            
                Buffer & operator=( Buffer && rhs ) = default;

            
            #else

            
                Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_buffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} ) )

            
                {}

            
                Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_buffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT

            
                  : m_buffer( buffer )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                Buffer & operator=(VkBuffer buffer) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_buffer = buffer;

            
                  return *this;

            
                }

            
            #endif


                Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_buffer = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_buffer;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_buffer != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_buffer == VK_NULL_HANDLE;

            
                }


              private:

            
                VkBuffer m_buffer = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Buffer;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Buffer;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkBuffer, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Buffer;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayout.html

            
              class PipelineLayout

            
              {

            
              public:

            
                using CType = VkPipelineLayout;

            
                using NativeType = VkPipelineLayout;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;


              public:

            
                PipelineLayout() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                PipelineLayout( PipelineLayout const & rhs ) = default;

            
                PipelineLayout & operator=( PipelineLayout const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                PipelineLayout( PipelineLayout && rhs ) = default;

            
                PipelineLayout & operator=( PipelineLayout && rhs ) = default;

            
            #else

            
                PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_pipelineLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) )

            
                {}

            
                PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipelineLayout = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT

            
                  : m_pipelineLayout( pipelineLayout )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                PipelineLayout & operator=(VkPipelineLayout pipelineLayout) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipelineLayout = pipelineLayout;

            
                  return *this;

            
                }

            
            #endif


                PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipelineLayout = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipelineLayout;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipelineLayout != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipelineLayout == VK_NULL_HANDLE;

            
                }


              private:

            
                VkPipelineLayout m_pipelineLayout = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkPipelineLayout, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSet.html

            
              class DescriptorSet

            
              {

            
              public:

            
                using CType = VkDescriptorSet;

            
                using NativeType = VkDescriptorSet;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;


              public:

            
                DescriptorSet() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DescriptorSet( DescriptorSet const & rhs ) = default;

            
                DescriptorSet & operator=( DescriptorSet const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DescriptorSet( DescriptorSet && rhs ) = default;

            
                DescriptorSet & operator=( DescriptorSet && rhs ) = default;

            
            #else

            
                DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_descriptorSet( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) )

            
                {}

            
                DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorSet = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT

            
                  : m_descriptorSet( descriptorSet )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DescriptorSet & operator=(VkDescriptorSet descriptorSet) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorSet = descriptorSet;

            
                  return *this;

            
                }

            
            #endif


                DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorSet = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorSet;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorSet != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorSet == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDescriptorSet m_descriptorSet = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDescriptorSet, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageView.html

            
              class ImageView

            
              {

            
              public:

            
                using CType = VkImageView;

            
                using NativeType = VkImageView;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;


              public:

            
                ImageView() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                ImageView( ImageView const & rhs ) = default;

            
                ImageView & operator=( ImageView const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                ImageView( ImageView && rhs ) = default;

            
                ImageView & operator=( ImageView && rhs ) = default;

            
            #else

            
                ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_imageView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} ) )

            
                {}

            
                ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_imageView = VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT

            
                  : m_imageView( imageView )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                ImageView & operator=(VkImageView imageView) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_imageView = imageView;

            
                  return *this;

            
                }

            
            #endif


                ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_imageView = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_imageView;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_imageView != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_imageView == VK_NULL_HANDLE;

            
                }


              private:

            
                VkImageView m_imageView = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ImageView;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ImageView;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkImageView, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ImageView;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipeline.html

            
              class Pipeline

            
              {

            
              public:

            
                using CType = VkPipeline;

            
                using NativeType = VkPipeline;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;


              public:

            
                Pipeline() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Pipeline( Pipeline const & rhs ) = default;

            
                Pipeline & operator=( Pipeline const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Pipeline( Pipeline && rhs ) = default;

            
                Pipeline & operator=( Pipeline && rhs ) = default;

            
            #else

            
                Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_pipeline( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} ) )

            
                {}

            
                Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipeline = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT

            
                  : m_pipeline( pipeline )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                Pipeline & operator=(VkPipeline pipeline) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipeline = pipeline;

            
                  return *this;

            
                }

            
            #endif


                Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipeline = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipeline;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipeline != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipeline == VK_NULL_HANDLE;

            
                }


              private:

            
                VkPipeline m_pipeline = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Pipeline;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Pipeline;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkPipeline, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Pipeline;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderEXT.html

            
              class ShaderEXT

            
              {

            
              public:

            
                using CType = VkShaderEXT;

            
                using NativeType = VkShaderEXT;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                ShaderEXT() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                ShaderEXT( ShaderEXT const & rhs ) = default;

            
                ShaderEXT & operator=( ShaderEXT const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                ShaderEXT( ShaderEXT && rhs ) = default;

            
                ShaderEXT & operator=( ShaderEXT && rhs ) = default;

            
            #else

            
                ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_shaderEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderEXT, {} ) )

            
                {}

            
                ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_shaderEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderEXT, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT

            
                  : m_shaderEXT( shaderEXT )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                ShaderEXT & operator=(VkShaderEXT shaderEXT) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_shaderEXT = shaderEXT;

            
                  return *this;

            
                }

            
            #endif


                ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_shaderEXT = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_shaderEXT;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_shaderEXT != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_shaderEXT == VK_NULL_HANDLE;

            
                }


              private:

            
                VkShaderEXT m_shaderEXT = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkShaderEXT, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderEXT>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html

            
              class Image

            
              {

            
              public:

            
                using CType = VkImage;

            
                using NativeType = VkImage;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;


              public:

            
                Image() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Image( Image const & rhs ) = default;

            
                Image & operator=( Image const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Image( Image && rhs ) = default;

            
                Image & operator=( Image && rhs ) = default;

            
            #else

            
                Image( Image && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_image( VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} ) )

            
                {}

            
                Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_image = VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT

            
                  : m_image( image )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                Image & operator=(VkImage image) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_image = image;

            
                  return *this;

            
                }

            
            #endif


                Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_image = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_image;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_image != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_image == VK_NULL_HANDLE;

            
                }


              private:

            
                VkImage m_image = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Image;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Image;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkImage, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Image;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureNV.html

            
              class AccelerationStructureNV

            
              {

            
              public:

            
                using CType = VkAccelerationStructureNV;

            
                using NativeType = VkAccelerationStructureNV;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;


              public:

            
                AccelerationStructureNV() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                AccelerationStructureNV( AccelerationStructureNV const & rhs ) = default;

            
                AccelerationStructureNV & operator=( AccelerationStructureNV const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                AccelerationStructureNV( AccelerationStructureNV && rhs ) = default;

            
                AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) = default;

            
            #else

            
                AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_accelerationStructureNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} ) )

            
                {}

            
                AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_accelerationStructureNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT

            
                  : m_accelerationStructureNV( accelerationStructureNV )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                AccelerationStructureNV & operator=(VkAccelerationStructureNV accelerationStructureNV) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_accelerationStructureNV = accelerationStructureNV;

            
                  return *this;

            
                }

            
            #endif


                AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_accelerationStructureNV = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_accelerationStructureNV;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_accelerationStructureNV != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_accelerationStructureNV == VK_NULL_HANDLE;

            
                }


              private:

            
                VkAccelerationStructureNV m_accelerationStructureNV = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkAccelerationStructureNV, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionNV.html

            
              class OpticalFlowSessionNV

            
              {

            
              public:

            
                using CType = VkOpticalFlowSessionNV;

            
                using NativeType = VkOpticalFlowSessionNV;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                OpticalFlowSessionNV() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                OpticalFlowSessionNV( OpticalFlowSessionNV const & rhs ) = default;

            
                OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) = default;

            
                OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) = default;

            
            #else

            
                OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_opticalFlowSessionNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_opticalFlowSessionNV, {} ) )

            
                {}

            
                OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_opticalFlowSessionNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_opticalFlowSessionNV, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT

            
                  : m_opticalFlowSessionNV( opticalFlowSessionNV )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                OpticalFlowSessionNV & operator=(VkOpticalFlowSessionNV opticalFlowSessionNV) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_opticalFlowSessionNV = opticalFlowSessionNV;

            
                  return *this;

            
                }

            
            #endif


                OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_opticalFlowSessionNV = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_opticalFlowSessionNV;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_opticalFlowSessionNV != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_opticalFlowSessionNV == VK_NULL_HANDLE;

            
                }


              private:

            
                VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkOpticalFlowSessionNV, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplate.html

            
              class DescriptorUpdateTemplate

            
              {

            
              public:

            
                using CType = VkDescriptorUpdateTemplate;

            
                using NativeType = VkDescriptorUpdateTemplate;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;


              public:

            
                DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DescriptorUpdateTemplate( DescriptorUpdateTemplate const & rhs ) = default;

            
                DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) = default;

            
                DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) = default;

            
            #else

            
                DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_descriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ) )

            
                {}

            
                DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorUpdateTemplate = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT

            
                  : m_descriptorUpdateTemplate( descriptorUpdateTemplate )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DescriptorUpdateTemplate & operator=(VkDescriptorUpdateTemplate descriptorUpdateTemplate) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorUpdateTemplate = descriptorUpdateTemplate;

            
                  return *this;

            
                }

            
            #endif


                DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorUpdateTemplate = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorUpdateTemplate;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorUpdateTemplate != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorUpdateTemplate == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDescriptorUpdateTemplate, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };

            
              using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;


              // wrapper class for handle VkEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEvent.html

            
              class Event

            
              {

            
              public:

            
                using CType = VkEvent;

            
                using NativeType = VkEvent;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;


              public:

            
                Event() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Event( Event const & rhs ) = default;

            
                Event & operator=( Event const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Event( Event && rhs ) = default;

            
                Event & operator=( Event && rhs ) = default;

            
            #else

            
                Event( Event && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_event( VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} ) )

            
                {}

            
                Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_event = VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT

            
                  : m_event( event )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                Event & operator=(VkEvent event) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_event = event;

            
                  return *this;

            
                }

            
            #endif


                Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_event = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_event;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_event != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_event == VK_NULL_HANDLE;

            
                }


              private:

            
                VkEvent m_event = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Event;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Event;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkEvent, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Event;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureKHR.html

            
              class AccelerationStructureKHR

            
              {

            
              public:

            
                using CType = VkAccelerationStructureKHR;

            
                using NativeType = VkAccelerationStructureKHR;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;


              public:

            
                AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                AccelerationStructureKHR( AccelerationStructureKHR const & rhs ) = default;

            
                AccelerationStructureKHR & operator=( AccelerationStructureKHR const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                AccelerationStructureKHR( AccelerationStructureKHR && rhs ) = default;

            
                AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) = default;

            
            #else

            
                AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_accelerationStructureKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} ) )

            
                {}

            
                AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_accelerationStructureKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT

            
                  : m_accelerationStructureKHR( accelerationStructureKHR )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                AccelerationStructureKHR & operator=(VkAccelerationStructureKHR accelerationStructureKHR) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_accelerationStructureKHR = accelerationStructureKHR;

            
                  return *this;

            
                }

            
            #endif


                AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_accelerationStructureKHR = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_accelerationStructureKHR;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_accelerationStructureKHR != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_accelerationStructureKHR == VK_NULL_HANDLE;

            
                }


              private:

            
                VkAccelerationStructureKHR m_accelerationStructureKHR = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkAccelerationStructureKHR, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapEXT.html

            
              class MicromapEXT

            
              {

            
              public:

            
                using CType = VkMicromapEXT;

            
                using NativeType = VkMicromapEXT;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                MicromapEXT() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                MicromapEXT( MicromapEXT const & rhs ) = default;

            
                MicromapEXT & operator=( MicromapEXT const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                MicromapEXT( MicromapEXT && rhs ) = default;

            
                MicromapEXT & operator=( MicromapEXT && rhs ) = default;

            
            #else

            
                MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_micromapEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_micromapEXT, {} ) )

            
                {}

            
                MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_micromapEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_micromapEXT, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT

            
                  : m_micromapEXT( micromapEXT )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                MicromapEXT & operator=(VkMicromapEXT micromapEXT) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_micromapEXT = micromapEXT;

            
                  return *this;

            
                }

            
            #endif


                MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_micromapEXT = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_micromapEXT;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_micromapEXT != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_micromapEXT == VK_NULL_HANDLE;

            
                }


              private:

            
                VkMicromapEXT m_micromapEXT = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkMicromapEXT, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::MicromapEXT>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBuffer.html

            
              class CommandBuffer

            
              {

            
              public:

            
                using CType = VkCommandBuffer;

            
                using NativeType = VkCommandBuffer;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;


              public:

            
                CommandBuffer() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                CommandBuffer( CommandBuffer const & rhs ) = default;

            
                CommandBuffer & operator=( CommandBuffer const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                CommandBuffer( CommandBuffer && rhs ) = default;

            
                CommandBuffer & operator=( CommandBuffer && rhs ) = default;

            
            #else

            
                CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_commandBuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) )

            
                {}

            
                CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_commandBuffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT

            
                  : m_commandBuffer( commandBuffer )

            
                {}


                CommandBuffer & operator=(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_commandBuffer = commandBuffer;

            
                  return *this;

            
                }


                CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_commandBuffer = {};

            
                  return *this;

            
                }


              //=== VK_VERSION_1_0 ===


                // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result end( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewport( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewport( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setScissor( uint32_t firstScissor, uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setScissor( uint32_t firstScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLineWidth( float lineWidth, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setBlendConstants( const float blendConstants[4], Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t * pDynamicOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::IndexType indexType, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindVertexBuffers( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions, VULKAN_HPP_NAMESPACE::Filter filter, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions, VULKAN_HPP_NAMESPACE::Filter filter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize dataSize, const void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize size, uint32_t data, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearColorValue * pColor, uint32_t rangeCount, const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearColorValue & color, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil, uint32_t rangeCount, const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void clearAttachments( uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments, uint32_t rectCount, const VULKAN_HPP_NAMESPACE::ClearRect * pRects, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setEvent( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resetEvent( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void waitEvents( uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event * pEvents, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, VULKAN_HPP_NAMESPACE::QueryControlFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void * pValues, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html

            
                template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, uint32_t offset, VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endRenderPass( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void executeCommands( uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_1 ===


                // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDeviceMask( uint32_t deviceMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_VERSION_1_2 ===


                // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawIndexedIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_3 ===


                // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resetEvent2( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void waitEvents2( uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event * pEvents, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endRendering( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportWithCount( uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setScissorWithCount( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindVertexBuffers2( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindVertexBuffers2( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthBoundsTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, VULKAN_HPP_NAMESPACE::StencilOp failOp, VULKAN_HPP_NAMESPACE::StencilOp passOp, VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, VULKAN_HPP_NAMESPACE::CompareOp compareOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetRasterizerDiscardEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetPrimitiveRestartEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_VERSION_1_4 ===


                // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindIndexBuffer2( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::IndexType indexType, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSet( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSet( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetRenderingAttachmentLocations, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRenderingAttachmentLocations( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo * pLocationInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetRenderingAttachmentLocations, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRenderingAttachmentLocations( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRenderingInputAttachmentIndices( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRenderingInputAttachmentIndices( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorSets2( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo * pBindDescriptorSetsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorSets2( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushConstants2( const VULKAN_HPP_NAMESPACE::PushConstantsInfo * pPushConstantsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushConstants2( const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSet2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo * pPushDescriptorSetInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSet2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetWithTemplate2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetWithTemplate2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_debug_marker ===


                // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void debugMarkerEndEXT( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_video_queue ===


                // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_video_decode_queue ===


                // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_transform_feedback ===


                // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBeginTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdEndTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdEndTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endTransformFeedbackEXT( uint32_t firstCounterBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, VULKAN_HPP_NAMESPACE::QueryControlFlags flags, uint32_t index, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawIndirectByteCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, VULKAN_HPP_NAMESPACE::Buffer counterBuffer, VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_NVX_binary_import ===


                // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_AMD_draw_indirect_count ===


                // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_dynamic_rendering ===


                // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endRenderingKHR( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_device_group ===


                // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_push_descriptor ===


                // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_conditional_rendering ===


                // wrapper function for command vkCmdBeginConditionalRenderingEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginConditionalRenderingEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdEndConditionalRenderingEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endConditionalRenderingEXT( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_NV_clip_space_w_scaling ===


                // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportWScalingNV( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_discard_rectangles ===


                // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_create_renderpass2 ===


                // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_debug_utils ===


                // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endDebugUtilsLabelEXT( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_AMDX_shader_enqueue ===


                // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, VULKAN_HPP_NAMESPACE::DeviceAddress scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchSize, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchSize, const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchSize, const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchSize, const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchSize, const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchSize, VULKAN_HPP_NAMESPACE::DeviceAddress countInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              //=== VK_EXT_sample_locations ===


                // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_acceleration_structure ===


                // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildAccelerationStructuresKHR( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildAccelerationStructuresIndirectKHR( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, const VULKAN_HPP_NAMESPACE::DeviceAddress * pIndirectDeviceAddresses, const uint32_t * pIndirectStrides, const uint32_t * const * ppMaxPrimitiveCounts, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildAccelerationStructuresIndirectKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeAccelerationStructuresPropertiesKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_ray_tracing_pipeline ===


                // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_NV_shading_rate_image ===


                // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportShadingRatePaletteNV( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_ray_tracing ===


                // wrapper function for command vkCmdBuildAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo, VULKAN_HPP_NAMESPACE::Buffer instanceData, VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, VULKAN_HPP_NAMESPACE::Bool32 update, VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::Buffer scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBuildAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info, VULKAN_HPP_NAMESPACE::Buffer instanceData, VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, VULKAN_HPP_NAMESPACE::Bool32 update, VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::Buffer scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeAccelerationStructuresPropertiesNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_draw_indirect_count ===


                // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_AMD_buffer_marker ===


                // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, uint32_t marker, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, uint32_t marker, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_NV_mesh_shader ===


                // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_NV_scissor_exclusive ===


                // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setExclusiveScissorNV( uint32_t firstExclusiveScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_device_diagnostic_checkpoints ===


                // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html

            
                template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCheckpointNV( CheckpointMarkerType const & checkpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_INTEL_performance_query ===


                // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_fragment_shading_rate ===


                // wrapper function for command vkCmdSetFragmentShadingRateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D * pFragmentSize, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetFragmentShadingRateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_dynamic_rendering_local_read ===


                // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo * pLocationInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_line_rasterization ===


                // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_extended_dynamic_state ===


                // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetViewportWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportWithCountEXT( uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetViewportWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setScissorWithCountEXT( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindVertexBuffers2EXT( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindVertexBuffers2EXT( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetStencilTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, VULKAN_HPP_NAMESPACE::StencilOp failOp, VULKAN_HPP_NAMESPACE::StencilOp passOp, VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, VULKAN_HPP_NAMESPACE::CompareOp compareOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_NV_device_generated_commands ===


                // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBindPipelineShaderGroupNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t groupIndex, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_depth_bias_control ===


                // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT * pDepthBiasInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_video_encode_queue ===


                // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_NV_cuda_kernel_launch ===


                // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV * pLaunchInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              //=== VK_QCOM_tile_shading ===


                // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchTileQCOM( const VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM * pDispatchTileInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void dispatchTileQCOM( const VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM & dispatchTileInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM * pPerTileBeginInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM & perTileBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM * pPerTileEndInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM & perTileEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_synchronization2 ===


                // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void waitEvents2KHR( uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event * pEvents, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_descriptor_buffer ===


                // wrapper function for command vkCmdBindDescriptorBuffersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorBuffersEXT( uint32_t bufferCount, const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindDescriptorBuffersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t * pBufferIndices, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_NV_fragment_shading_rate_enums ===


                // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_mesh_shader ===


                // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_copy_commands2 ===


                // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_vertex_input_dynamic_state ===


                // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setVertexInputEXT( uint32_t vertexBindingDescriptionCount, const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_HUAWEI_subpass_shading ===


                // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void subpassShadingHUAWEI( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_HUAWEI_invocation_mask ===


                // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_extended_dynamic_state2 ===


                // wrapper function for command vkCmdSetPatchControlPointsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_color_write_enable ===


                // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorWriteEnableEXT( uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_ray_tracing_maintenance1 ===


                // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_multi_draw ===


                // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMultiEXT( uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo, uint32_t instanceCount, uint32_t firstInstance, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMultiIndexedEXT( uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t * pVertexOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo, uint32_t instanceCount, uint32_t firstInstance, Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_opacity_micromap ===


                // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildMicromapsEXT( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeMicromapsPropertiesEXT( uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_HUAWEI_cluster_culling_shader ===


                // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_NV_copy_memory_indirect ===


                // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t stride, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_memory_decompression ===


                // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void decompressMemoryNV( uint32_t decompressRegionCount, const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress, VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_NV_device_generated_commands_compute ===


                // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_extended_dynamic_state3 ===


                // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetRasterizationSamplesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, const VULKAN_HPP_NAMESPACE::SampleMask * pSampleMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorBlendEnableEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorBlendEnableEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetColorBlendEquationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorBlendEquationEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetColorBlendEquationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorBlendEquationEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorWriteMaskEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorWriteMaskEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetRasterizationStreamEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorBlendAdvancedEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setColorBlendAdvancedEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetProvokingVertexModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetLineRasterizationModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetLineStippleEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetViewportWScalingEnableNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportSwizzleNV( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setViewportSwizzleNV( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetCoverageToColorEnableNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetCoverageToColorLocationNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCoverageToColorLocationNV( uint32_t coverageToColorLocation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetCoverageModulationModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetCoverageModulationTableNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCoverageModulationTableNV( uint32_t coverageModulationTableCount, const float * pCoverageModulationTable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetCoverageModulationTableNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetShadingRateImageEnableNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkCmdSetCoverageReductionModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_ARM_tensors ===


                // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyTensorARM( const VULKAN_HPP_NAMESPACE::CopyTensorInfoARM * pCopyTensorInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void copyTensorARM( const VULKAN_HPP_NAMESPACE::CopyTensorInfoARM & copyTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_optical_flow ===


                // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_maintenance5 ===


                // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::IndexType indexType, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_shader_object ===


                // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindShadersEXT( uint32_t stageCount, const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits * pStages, const VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & shaders, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthClampRangeEXT( VULKAN_HPP_NAMESPACE::DepthClampModeEXT depthClampMode, const VULKAN_HPP_NAMESPACE::DepthClampRangeEXT * pDepthClampRange, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDepthClampRangeEXT( VULKAN_HPP_NAMESPACE::DepthClampModeEXT depthClampMode, Optional<const VULKAN_HPP_NAMESPACE::DepthClampRangeEXT> depthClampRange VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_cooperative_vector ===


                // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void convertCooperativeVectorMatrixNV( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV * pInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void convertCooperativeVectorMatrixNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV> const & infos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_attachment_feedback_loop_dynamic_state ===


                // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_line_rasterization ===


                // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_maintenance6 ===


                // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo * pBindDescriptorSetsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfo * pPushConstantsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo * pPushDescriptorSetInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorBufferEmbeddedSamplers2EXT( const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindDescriptorBufferEmbeddedSamplers2EXT( const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_QCOM_tile_memory_heap ===


                // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindTileMemoryQCOM( const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM * pTileMemoryBindInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void bindTileMemoryQCOM( Optional<const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM> tileMemoryBindInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_cluster_acceleration_structure ===


                // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildClusterAccelerationStructureIndirectNV( const VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV * pCommandInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildClusterAccelerationStructureIndirectNV( const VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV & commandInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_partitioned_acceleration_structure ===


                // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildPartitionedAccelerationStructuresNV( const VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV * pBuildInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void buildPartitionedAccelerationStructuresNV( const VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV & buildInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_device_generated_commands ===


                // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void preprocessGeneratedCommandsEXT( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, VULKAN_HPP_NAMESPACE::CommandBuffer stateCommandBuffer, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void preprocessGeneratedCommandsEXT( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT & generatedCommandsInfo, VULKAN_HPP_NAMESPACE::CommandBuffer stateCommandBuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void executeGeneratedCommandsEXT( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void executeGeneratedCommandsEXT( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT & generatedCommandsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_fragment_density_map_offset ===


                // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endRendering2EXT( const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT * pRenderingEndInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_commandBuffer;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_commandBuffer != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_commandBuffer == VK_NULL_HANDLE;

            
                }


              private:

            
                VkCommandBuffer m_commandBuffer = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkCommandBuffer, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDeviceMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemory.html

            
              class DeviceMemory

            
              {

            
              public:

            
                using CType = VkDeviceMemory;

            
                using NativeType = VkDeviceMemory;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;


              public:

            
                DeviceMemory() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DeviceMemory( DeviceMemory const & rhs ) = default;

            
                DeviceMemory & operator=( DeviceMemory const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DeviceMemory( DeviceMemory && rhs ) = default;

            
                DeviceMemory & operator=( DeviceMemory && rhs ) = default;

            
            #else

            
                DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_deviceMemory( VULKAN_HPP_NAMESPACE::exchange( rhs.m_deviceMemory, {} ) )

            
                {}

            
                DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_deviceMemory = VULKAN_HPP_NAMESPACE::exchange( rhs.m_deviceMemory, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT

            
                  : m_deviceMemory( deviceMemory )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DeviceMemory & operator=(VkDeviceMemory deviceMemory) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_deviceMemory = deviceMemory;

            
                  return *this;

            
                }

            
            #endif


                DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_deviceMemory = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_deviceMemory;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_deviceMemory != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_deviceMemory == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDeviceMemory m_deviceMemory = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDeviceMemory, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionKHR.html

            
              class VideoSessionKHR

            
              {

            
              public:

            
                using CType = VkVideoSessionKHR;

            
                using NativeType = VkVideoSessionKHR;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                VideoSessionKHR() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                VideoSessionKHR( VideoSessionKHR const & rhs ) = default;

            
                VideoSessionKHR & operator=( VideoSessionKHR const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                VideoSessionKHR( VideoSessionKHR && rhs ) = default;

            
                VideoSessionKHR & operator=( VideoSessionKHR && rhs ) = default;

            
            #else

            
                VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_videoSessionKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} ) )

            
                {}

            
                VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_videoSessionKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT

            
                  : m_videoSessionKHR( videoSessionKHR )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                VideoSessionKHR & operator=(VkVideoSessionKHR videoSessionKHR) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_videoSessionKHR = videoSessionKHR;

            
                  return *this;

            
                }

            
            #endif


                VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_videoSessionKHR = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_videoSessionKHR;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_videoSessionKHR != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_videoSessionKHR == VK_NULL_HANDLE;

            
                }


              private:

            
                VkVideoSessionKHR m_videoSessionKHR = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkVideoSessionKHR, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeferredOperationKHR.html

            
              class DeferredOperationKHR

            
              {

            
              public:

            
                using CType = VkDeferredOperationKHR;

            
                using NativeType = VkDeferredOperationKHR;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                DeferredOperationKHR() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DeferredOperationKHR( DeferredOperationKHR const & rhs ) = default;

            
                DeferredOperationKHR & operator=( DeferredOperationKHR const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DeferredOperationKHR( DeferredOperationKHR && rhs ) = default;

            
                DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) = default;

            
            #else

            
                DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_deferredOperationKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_deferredOperationKHR, {} ) )

            
                {}

            
                DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_deferredOperationKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_deferredOperationKHR, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT

            
                  : m_deferredOperationKHR( deferredOperationKHR )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DeferredOperationKHR & operator=(VkDeferredOperationKHR deferredOperationKHR) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_deferredOperationKHR = deferredOperationKHR;

            
                  return *this;

            
                }

            
            #endif


                DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_deferredOperationKHR = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_deferredOperationKHR;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_deferredOperationKHR != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_deferredOperationKHR == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDeferredOperationKHR m_deferredOperationKHR = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDeferredOperationKHR, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionFUCHSIA.html

            
            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              class BufferCollectionFUCHSIA

            
              {

            
              public:

            
                using CType = VkBufferCollectionFUCHSIA;

            
                using NativeType = VkBufferCollectionFUCHSIA;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;


              public:

            
                BufferCollectionFUCHSIA() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & rhs ) = default;

            
                BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) = default;

            
                BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) = default;

            
            #else

            
                BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_bufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} ) )

            
                {}

            
                BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_bufferCollectionFUCHSIA = VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT

            
                  : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                BufferCollectionFUCHSIA & operator=(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;

            
                  return *this;

            
                }

            
            #endif


                BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_bufferCollectionFUCHSIA = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_bufferCollectionFUCHSIA;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;

            
                }


              private:

            
                VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkBufferCollectionFUCHSIA, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


              // wrapper class for handle VkBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferView.html

            
              class BufferView

            
              {

            
              public:

            
                using CType = VkBufferView;

            
                using NativeType = VkBufferView;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;


              public:

            
                BufferView() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                BufferView( BufferView const & rhs ) = default;

            
                BufferView & operator=( BufferView const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                BufferView( BufferView && rhs ) = default;

            
                BufferView & operator=( BufferView && rhs ) = default;

            
            #else

            
                BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_bufferView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} ) )

            
                {}

            
                BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_bufferView = VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT

            
                  : m_bufferView( bufferView )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                BufferView & operator=(VkBufferView bufferView) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_bufferView = bufferView;

            
                  return *this;

            
                }

            
            #endif


                BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_bufferView = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_bufferView;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_bufferView != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_bufferView == VK_NULL_HANDLE;

            
                }


              private:

            
                VkBufferView m_bufferView = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::BufferView;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::BufferView;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkBufferView, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::BufferView;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPool.html

            
              class CommandPool

            
              {

            
              public:

            
                using CType = VkCommandPool;

            
                using NativeType = VkCommandPool;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;


              public:

            
                CommandPool() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                CommandPool( CommandPool const & rhs ) = default;

            
                CommandPool & operator=( CommandPool const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                CommandPool( CommandPool && rhs ) = default;

            
                CommandPool & operator=( CommandPool && rhs ) = default;

            
            #else

            
                CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_commandPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} ) )

            
                {}

            
                CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_commandPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT

            
                  : m_commandPool( commandPool )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                CommandPool & operator=(VkCommandPool commandPool) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_commandPool = commandPool;

            
                  return *this;

            
                }

            
            #endif


                CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_commandPool = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_commandPool;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_commandPool != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_commandPool == VK_NULL_HANDLE;

            
                }


              private:

            
                VkCommandPool m_commandPool = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CommandPool;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CommandPool;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkCommandPool, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CommandPool;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCache.html

            
              class PipelineCache

            
              {

            
              public:

            
                using CType = VkPipelineCache;

            
                using NativeType = VkPipelineCache;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;


              public:

            
                PipelineCache() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                PipelineCache( PipelineCache const & rhs ) = default;

            
                PipelineCache & operator=( PipelineCache const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                PipelineCache( PipelineCache && rhs ) = default;

            
                PipelineCache & operator=( PipelineCache && rhs ) = default;

            
            #else

            
                PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_pipelineCache( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) )

            
                {}

            
                PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipelineCache = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT

            
                  : m_pipelineCache( pipelineCache )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                PipelineCache & operator=(VkPipelineCache pipelineCache) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipelineCache = pipelineCache;

            
                  return *this;

            
                }

            
            #endif


                PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipelineCache = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipelineCache;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipelineCache != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipelineCache == VK_NULL_HANDLE;

            
                }


              private:

            
                VkPipelineCache m_pipelineCache = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PipelineCache;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PipelineCache;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkPipelineCache, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PipelineCache;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionNVX.html

            
              class CuFunctionNVX

            
              {

            
              public:

            
                using CType = VkCuFunctionNVX;

            
                using NativeType = VkCuFunctionNVX;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;


              public:

            
                CuFunctionNVX() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                CuFunctionNVX( CuFunctionNVX const & rhs ) = default;

            
                CuFunctionNVX & operator=( CuFunctionNVX const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                CuFunctionNVX( CuFunctionNVX && rhs ) = default;

            
                CuFunctionNVX & operator=( CuFunctionNVX && rhs ) = default;

            
            #else

            
                CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_cuFunctionNVX( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} ) )

            
                {}

            
                CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cuFunctionNVX = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT

            
                  : m_cuFunctionNVX( cuFunctionNVX )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                CuFunctionNVX & operator=(VkCuFunctionNVX cuFunctionNVX) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cuFunctionNVX = cuFunctionNVX;

            
                  return *this;

            
                }

            
            #endif


                CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cuFunctionNVX = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cuFunctionNVX;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cuFunctionNVX != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cuFunctionNVX == VK_NULL_HANDLE;

            
                }


              private:

            
                VkCuFunctionNVX m_cuFunctionNVX = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkCuFunctionNVX, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleNVX.html

            
              class CuModuleNVX

            
              {

            
              public:

            
                using CType = VkCuModuleNVX;

            
                using NativeType = VkCuModuleNVX;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;


              public:

            
                CuModuleNVX() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                CuModuleNVX( CuModuleNVX const & rhs ) = default;

            
                CuModuleNVX & operator=( CuModuleNVX const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                CuModuleNVX( CuModuleNVX && rhs ) = default;

            
                CuModuleNVX & operator=( CuModuleNVX && rhs ) = default;

            
            #else

            
                CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_cuModuleNVX( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} ) )

            
                {}

            
                CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cuModuleNVX = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT

            
                  : m_cuModuleNVX( cuModuleNVX )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                CuModuleNVX & operator=(VkCuModuleNVX cuModuleNVX) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cuModuleNVX = cuModuleNVX;

            
                  return *this;

            
                }

            
            #endif


                CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cuModuleNVX = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cuModuleNVX;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cuModuleNVX != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cuModuleNVX == VK_NULL_HANDLE;

            
                }


              private:

            
                VkCuModuleNVX m_cuModuleNVX = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkCuModuleNVX, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionNV.html

            
            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              class CudaFunctionNV

            
              {

            
              public:

            
                using CType = VkCudaFunctionNV;

            
                using NativeType = VkCudaFunctionNV;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV;


              public:

            
                CudaFunctionNV() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                CudaFunctionNV( CudaFunctionNV const & rhs ) = default;

            
                CudaFunctionNV & operator=( CudaFunctionNV const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                CudaFunctionNV( CudaFunctionNV && rhs ) = default;

            
                CudaFunctionNV & operator=( CudaFunctionNV && rhs ) = default;

            
            #else

            
                CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_cudaFunctionNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaFunctionNV, {} ) )

            
                {}

            
                CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cudaFunctionNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaFunctionNV, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT

            
                  : m_cudaFunctionNV( cudaFunctionNV )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                CudaFunctionNV & operator=(VkCudaFunctionNV cudaFunctionNV) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cudaFunctionNV = cudaFunctionNV;

            
                  return *this;

            
                }

            
            #endif


                CudaFunctionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cudaFunctionNV = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cudaFunctionNV;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cudaFunctionNV != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cudaFunctionNV == VK_NULL_HANDLE;

            
                }


              private:

            
                VkCudaFunctionNV m_cudaFunctionNV = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkCudaFunctionNV, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              // wrapper class for handle VkCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleNV.html

            
            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              class CudaModuleNV

            
              {

            
              public:

            
                using CType = VkCudaModuleNV;

            
                using NativeType = VkCudaModuleNV;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV;


              public:

            
                CudaModuleNV() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                CudaModuleNV( CudaModuleNV const & rhs ) = default;

            
                CudaModuleNV & operator=( CudaModuleNV const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                CudaModuleNV( CudaModuleNV && rhs ) = default;

            
                CudaModuleNV & operator=( CudaModuleNV && rhs ) = default;

            
            #else

            
                CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_cudaModuleNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaModuleNV, {} ) )

            
                {}

            
                CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cudaModuleNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaModuleNV, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT

            
                  : m_cudaModuleNV( cudaModuleNV )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                CudaModuleNV & operator=(VkCudaModuleNV cudaModuleNV) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cudaModuleNV = cudaModuleNV;

            
                  return *this;

            
                }

            
            #endif


                CudaModuleNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_cudaModuleNV = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cudaModuleNV;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cudaModuleNV != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_cudaModuleNV == VK_NULL_HANDLE;

            
                }


              private:

            
                VkCudaModuleNV m_cudaModuleNV = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkCudaModuleNV, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaModuleNV>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              // wrapper class for handle VkDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPool.html

            
              class DescriptorPool

            
              {

            
              public:

            
                using CType = VkDescriptorPool;

            
                using NativeType = VkDescriptorPool;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;


              public:

            
                DescriptorPool() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DescriptorPool( DescriptorPool const & rhs ) = default;

            
                DescriptorPool & operator=( DescriptorPool const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DescriptorPool( DescriptorPool && rhs ) = default;

            
                DescriptorPool & operator=( DescriptorPool && rhs ) = default;

            
            #else

            
                DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_descriptorPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) )

            
                {}

            
                DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT

            
                  : m_descriptorPool( descriptorPool )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DescriptorPool & operator=(VkDescriptorPool descriptorPool) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorPool = descriptorPool;

            
                  return *this;

            
                }

            
            #endif


                DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorPool = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorPool;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorPool != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorPool == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDescriptorPool m_descriptorPool = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDescriptorPool, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayout.html

            
              class DescriptorSetLayout

            
              {

            
              public:

            
                using CType = VkDescriptorSetLayout;

            
                using NativeType = VkDescriptorSetLayout;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;


              public:

            
                DescriptorSetLayout() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default;

            
                DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DescriptorSetLayout( DescriptorSetLayout && rhs ) = default;

            
                DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default;

            
            #else

            
                DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) )

            
                {}

            
                DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorSetLayout = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT

            
                  : m_descriptorSetLayout( descriptorSetLayout )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorSetLayout = descriptorSetLayout;

            
                  return *this;

            
                }

            
            #endif


                DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_descriptorSetLayout = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorSetLayout;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorSetLayout != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_descriptorSetLayout == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDescriptorSetLayout m_descriptorSetLayout = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDescriptorSetLayout, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html

            
              class ExternalComputeQueueNV

            
              {

            
              public:

            
                using CType = VkExternalComputeQueueNV;

            
                using NativeType = VkExternalComputeQueueNV;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eExternalComputeQueueNV;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                ExternalComputeQueueNV() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                ExternalComputeQueueNV( ExternalComputeQueueNV const & rhs ) = default;

            
                ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) = default;

            
                ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) = default;

            
            #else

            
                ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_externalComputeQueueNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_externalComputeQueueNV, {} ) )

            
                {}

            
                ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_externalComputeQueueNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_externalComputeQueueNV, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR ExternalComputeQueueNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                ExternalComputeQueueNV( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT

            
                  : m_externalComputeQueueNV( externalComputeQueueNV )

            
                {}


                ExternalComputeQueueNV & operator=(VkExternalComputeQueueNV externalComputeQueueNV) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_externalComputeQueueNV = externalComputeQueueNV;

            
                  return *this;

            
                }


                ExternalComputeQueueNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_externalComputeQueueNV = {};

            
                  return *this;

            
                }


              //=== VK_NV_external_compute_queue ===


                // wrapper function for command vkGetExternalComputeQueueDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getData( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV * params, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetExternalComputeQueueDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV, DataType> getData( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                operator VkExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_externalComputeQueueNV;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_externalComputeQueueNV != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_externalComputeQueueNV == VK_NULL_HANDLE;

            
                }


              private:

            
                VkExternalComputeQueueNV m_externalComputeQueueNV = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eExternalComputeQueueNV>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkExternalComputeQueueNV, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebuffer.html

            
              class Framebuffer

            
              {

            
              public:

            
                using CType = VkFramebuffer;

            
                using NativeType = VkFramebuffer;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;


              public:

            
                Framebuffer() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Framebuffer( Framebuffer const & rhs ) = default;

            
                Framebuffer & operator=( Framebuffer const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Framebuffer( Framebuffer && rhs ) = default;

            
                Framebuffer & operator=( Framebuffer && rhs ) = default;

            
            #else

            
                Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_framebuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} ) )

            
                {}

            
                Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_framebuffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT

            
                  : m_framebuffer( framebuffer )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                Framebuffer & operator=(VkFramebuffer framebuffer) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_framebuffer = framebuffer;

            
                  return *this;

            
                }

            
            #endif


                Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_framebuffer = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_framebuffer;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_framebuffer != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_framebuffer == VK_NULL_HANDLE;

            
                }


              private:

            
                VkFramebuffer m_framebuffer = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Framebuffer;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Framebuffer;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkFramebuffer, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Framebuffer;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutEXT.html

            
              class IndirectCommandsLayoutEXT

            
              {

            
              public:

            
                using CType = VkIndirectCommandsLayoutEXT;

            
                using NativeType = VkIndirectCommandsLayoutEXT;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutEXT;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                IndirectCommandsLayoutEXT() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT const & rhs ) = default;

            
                IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) = default;

            
                IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) = default;

            
            #else

            
                IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_indirectCommandsLayoutEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutEXT, {} ) )

            
                {}

            
                IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_indirectCommandsLayoutEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutEXT, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutEXT( VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT ) VULKAN_HPP_NOEXCEPT

            
                  : m_indirectCommandsLayoutEXT( indirectCommandsLayoutEXT )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                IndirectCommandsLayoutEXT & operator=(VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_indirectCommandsLayoutEXT = indirectCommandsLayoutEXT;

            
                  return *this;

            
                }

            
            #endif


                IndirectCommandsLayoutEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_indirectCommandsLayoutEXT = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutEXT() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_indirectCommandsLayoutEXT;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_indirectCommandsLayoutEXT != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_indirectCommandsLayoutEXT == VK_NULL_HANDLE;

            
                }


              private:

            
                VkIndirectCommandsLayoutEXT m_indirectCommandsLayoutEXT = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutEXT>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkIndirectCommandsLayoutEXT, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutNV.html

            
              class IndirectCommandsLayoutNV

            
              {

            
              public:

            
                using CType = VkIndirectCommandsLayoutNV;

            
                using NativeType = VkIndirectCommandsLayoutNV;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & rhs ) = default;

            
                IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) = default;

            
                IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) = default;

            
            #else

            
                IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_indirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} ) )

            
                {}

            
                IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_indirectCommandsLayoutNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT

            
                  : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                IndirectCommandsLayoutNV & operator=(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;

            
                  return *this;

            
                }

            
            #endif


                IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_indirectCommandsLayoutNV = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_indirectCommandsLayoutNV;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;

            
                }


              private:

            
                VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkIndirectCommandsLayoutNV, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetEXT.html

            
              class IndirectExecutionSetEXT

            
              {

            
              public:

            
                using CType = VkIndirectExecutionSetEXT;

            
                using NativeType = VkIndirectExecutionSetEXT;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectExecutionSetEXT;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                IndirectExecutionSetEXT() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                IndirectExecutionSetEXT( IndirectExecutionSetEXT const & rhs ) = default;

            
                IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) = default;

            
                IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) = default;

            
            #else

            
                IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_indirectExecutionSetEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectExecutionSetEXT, {} ) )

            
                {}

            
                IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_indirectExecutionSetEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectExecutionSetEXT, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR IndirectExecutionSetEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT IndirectExecutionSetEXT( VkIndirectExecutionSetEXT indirectExecutionSetEXT ) VULKAN_HPP_NOEXCEPT

            
                  : m_indirectExecutionSetEXT( indirectExecutionSetEXT )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                IndirectExecutionSetEXT & operator=(VkIndirectExecutionSetEXT indirectExecutionSetEXT) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_indirectExecutionSetEXT = indirectExecutionSetEXT;

            
                  return *this;

            
                }

            
            #endif


                IndirectExecutionSetEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_indirectExecutionSetEXT = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectExecutionSetEXT() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_indirectExecutionSetEXT;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_indirectExecutionSetEXT != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_indirectExecutionSetEXT == VK_NULL_HANDLE;

            
                }


              private:

            
                VkIndirectExecutionSetEXT m_indirectExecutionSetEXT = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectExecutionSetEXT>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkIndirectExecutionSetEXT, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlot.html

            
              class PrivateDataSlot

            
              {

            
              public:

            
                using CType = VkPrivateDataSlot;

            
                using NativeType = VkPrivateDataSlot;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                PrivateDataSlot() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                PrivateDataSlot( PrivateDataSlot const & rhs ) = default;

            
                PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                PrivateDataSlot( PrivateDataSlot && rhs ) = default;

            
                PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default;

            
            #else

            
                PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_privateDataSlot( VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) )

            
                {}

            
                PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_privateDataSlot = VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT

            
                  : m_privateDataSlot( privateDataSlot )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                PrivateDataSlot & operator=(VkPrivateDataSlot privateDataSlot) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_privateDataSlot = privateDataSlot;

            
                  return *this;

            
                }

            
            #endif


                PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_privateDataSlot = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_privateDataSlot;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_privateDataSlot != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_privateDataSlot == VK_NULL_HANDLE;

            
                }


              private:

            
                VkPrivateDataSlot m_privateDataSlot = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkPrivateDataSlot, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };

            
              using PrivateDataSlotEXT = PrivateDataSlot;


              // wrapper class for handle VkRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPass.html

            
              class RenderPass

            
              {

            
              public:

            
                using CType = VkRenderPass;

            
                using NativeType = VkRenderPass;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;


              public:

            
                RenderPass() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                RenderPass( RenderPass const & rhs ) = default;

            
                RenderPass & operator=( RenderPass const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                RenderPass( RenderPass && rhs ) = default;

            
                RenderPass & operator=( RenderPass && rhs ) = default;

            
            #else

            
                RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_renderPass( VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} ) )

            
                {}

            
                RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_renderPass = VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT

            
                  : m_renderPass( renderPass )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                RenderPass & operator=(VkRenderPass renderPass) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_renderPass = renderPass;

            
                  return *this;

            
                }

            
            #endif


                RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_renderPass = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_renderPass;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_renderPass != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_renderPass == VK_NULL_HANDLE;

            
                }


              private:

            
                VkRenderPass m_renderPass = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::RenderPass;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::RenderPass;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkRenderPass, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::RenderPass;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampler.html

            
              class Sampler

            
              {

            
              public:

            
                using CType = VkSampler;

            
                using NativeType = VkSampler;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;


              public:

            
                Sampler() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Sampler( Sampler const & rhs ) = default;

            
                Sampler & operator=( Sampler const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Sampler( Sampler && rhs ) = default;

            
                Sampler & operator=( Sampler && rhs ) = default;

            
            #else

            
                Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_sampler( VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} ) )

            
                {}

            
                Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_sampler = VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT

            
                  : m_sampler( sampler )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                Sampler & operator=(VkSampler sampler) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_sampler = sampler;

            
                  return *this;

            
                }

            
            #endif


                Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_sampler = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_sampler;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_sampler != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_sampler == VK_NULL_HANDLE;

            
                }


              private:

            
                VkSampler m_sampler = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Sampler;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Sampler;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkSampler, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Sampler;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversion.html

            
              class SamplerYcbcrConversion

            
              {

            
              public:

            
                using CType = VkSamplerYcbcrConversion;

            
                using NativeType = VkSamplerYcbcrConversion;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;


              public:

            
                SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default;

            
                SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default;

            
                SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default;

            
            #else

            
                SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_samplerYcbcrConversion( VULKAN_HPP_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} ) )

            
                {}

            
                SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_samplerYcbcrConversion = VULKAN_HPP_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT

            
                  : m_samplerYcbcrConversion( samplerYcbcrConversion )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_samplerYcbcrConversion = samplerYcbcrConversion;

            
                  return *this;

            
                }

            
            #endif


                SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_samplerYcbcrConversion = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_samplerYcbcrConversion;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_samplerYcbcrConversion != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_samplerYcbcrConversion == VK_NULL_HANDLE;

            
                }


              private:

            
                VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkSamplerYcbcrConversion, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };

            
              using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;


              // wrapper class for handle VkShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModule.html

            
              class ShaderModule

            
              {

            
              public:

            
                using CType = VkShaderModule;

            
                using NativeType = VkShaderModule;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;


              public:

            
                ShaderModule() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                ShaderModule( ShaderModule const & rhs ) = default;

            
                ShaderModule & operator=( ShaderModule const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                ShaderModule( ShaderModule && rhs ) = default;

            
                ShaderModule & operator=( ShaderModule && rhs ) = default;

            
            #else

            
                ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_shaderModule( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} ) )

            
                {}

            
                ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_shaderModule = VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT

            
                  : m_shaderModule( shaderModule )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                ShaderModule & operator=(VkShaderModule shaderModule) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_shaderModule = shaderModule;

            
                  return *this;

            
                }

            
            #endif


                ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_shaderModule = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_shaderModule;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_shaderModule != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_shaderModule == VK_NULL_HANDLE;

            
                }


              private:

            
                VkShaderModule m_shaderModule = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ShaderModule;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ShaderModule;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkShaderModule, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ShaderModule;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorARM.html

            
              class TensorARM

            
              {

            
              public:

            
                using CType = VkTensorARM;

            
                using NativeType = VkTensorARM;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eTensorARM;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                TensorARM() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                TensorARM( TensorARM const & rhs ) = default;

            
                TensorARM & operator=( TensorARM const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                TensorARM( TensorARM && rhs ) = default;

            
                TensorARM & operator=( TensorARM && rhs ) = default;

            
            #else

            
                TensorARM( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_tensorARM( VULKAN_HPP_NAMESPACE::exchange( rhs.m_tensorARM, {} ) )

            
                {}

            
                TensorARM & operator=( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_tensorARM = VULKAN_HPP_NAMESPACE::exchange( rhs.m_tensorARM, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR TensorARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT TensorARM( VkTensorARM tensorARM ) VULKAN_HPP_NOEXCEPT

            
                  : m_tensorARM( tensorARM )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                TensorARM & operator=(VkTensorARM tensorARM) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_tensorARM = tensorARM;

            
                  return *this;

            
                }

            
            #endif


                TensorARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_tensorARM = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorARM() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_tensorARM;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_tensorARM != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_tensorARM == VK_NULL_HANDLE;

            
                }


              private:

            
                VkTensorARM m_tensorARM = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eTensorARM>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::TensorARM;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkTensorARM, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::TensorARM;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::TensorARM>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewARM.html

            
              class TensorViewARM

            
              {

            
              public:

            
                using CType = VkTensorViewARM;

            
                using NativeType = VkTensorViewARM;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eTensorViewARM;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                TensorViewARM() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                TensorViewARM( TensorViewARM const & rhs ) = default;

            
                TensorViewARM & operator=( TensorViewARM const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                TensorViewARM( TensorViewARM && rhs ) = default;

            
                TensorViewARM & operator=( TensorViewARM && rhs ) = default;

            
            #else

            
                TensorViewARM( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_tensorViewARM( VULKAN_HPP_NAMESPACE::exchange( rhs.m_tensorViewARM, {} ) )

            
                {}

            
                TensorViewARM & operator=( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_tensorViewARM = VULKAN_HPP_NAMESPACE::exchange( rhs.m_tensorViewARM, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR TensorViewARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT TensorViewARM( VkTensorViewARM tensorViewARM ) VULKAN_HPP_NOEXCEPT

            
                  : m_tensorViewARM( tensorViewARM )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                TensorViewARM & operator=(VkTensorViewARM tensorViewARM) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_tensorViewARM = tensorViewARM;

            
                  return *this;

            
                }

            
            #endif


                TensorViewARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_tensorViewARM = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorViewARM() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_tensorViewARM;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_tensorViewARM != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_tensorViewARM == VK_NULL_HANDLE;

            
                }


              private:

            
                VkTensorViewARM m_tensorViewARM = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eTensorViewARM>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::TensorViewARM;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkTensorViewARM, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::TensorViewARM;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::TensorViewARM>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheEXT.html

            
              class ValidationCacheEXT

            
              {

            
              public:

            
                using CType = VkValidationCacheEXT;

            
                using NativeType = VkValidationCacheEXT;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;


              public:

            
                ValidationCacheEXT() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                ValidationCacheEXT( ValidationCacheEXT const & rhs ) = default;

            
                ValidationCacheEXT & operator=( ValidationCacheEXT const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                ValidationCacheEXT( ValidationCacheEXT && rhs ) = default;

            
                ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) = default;

            
            #else

            
                ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_validationCacheEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_validationCacheEXT, {} ) )

            
                {}

            
                ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_validationCacheEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_validationCacheEXT, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT

            
                  : m_validationCacheEXT( validationCacheEXT )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_validationCacheEXT = validationCacheEXT;

            
                  return *this;

            
                }

            
            #endif


                ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_validationCacheEXT = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_validationCacheEXT;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_validationCacheEXT != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_validationCacheEXT == VK_NULL_HANDLE;

            
                }


              private:

            
                VkValidationCacheEXT m_validationCacheEXT = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkValidationCacheEXT, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersKHR.html

            
              class VideoSessionParametersKHR

            
              {

            
              public:

            
                using CType = VkVideoSessionParametersKHR;

            
                using NativeType = VkVideoSessionParametersKHR;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                VideoSessionParametersKHR( VideoSessionParametersKHR const & rhs ) = default;

            
                VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) = default;

            
                VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) = default;

            
            #else

            
                VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_videoSessionParametersKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} ) )

            
                {}

            
                VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_videoSessionParametersKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT

            
                  : m_videoSessionParametersKHR( videoSessionParametersKHR )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                VideoSessionParametersKHR & operator=(VkVideoSessionParametersKHR videoSessionParametersKHR) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_videoSessionParametersKHR = videoSessionParametersKHR;

            
                  return *this;

            
                }

            
            #endif


                VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_videoSessionParametersKHR = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_videoSessionParametersKHR;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_videoSessionParametersKHR != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_videoSessionParametersKHR == VK_NULL_HANDLE;

            
                }


              private:

            
                VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkVideoSessionParametersKHR, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKHR.html

            
              class PipelineBinaryKHR

            
              {

            
              public:

            
                using CType = VkPipelineBinaryKHR;

            
                using NativeType = VkPipelineBinaryKHR;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;


              public:

            
                PipelineBinaryKHR() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                PipelineBinaryKHR( PipelineBinaryKHR const & rhs ) = default;

            
                PipelineBinaryKHR & operator=( PipelineBinaryKHR const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                PipelineBinaryKHR( PipelineBinaryKHR && rhs ) = default;

            
                PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) = default;

            
            #else

            
                PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_pipelineBinaryKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinaryKHR, {} ) )

            
                {}

            
                PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipelineBinaryKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinaryKHR, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR PipelineBinaryKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT PipelineBinaryKHR( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT

            
                  : m_pipelineBinaryKHR( pipelineBinaryKHR )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                PipelineBinaryKHR & operator=(VkPipelineBinaryKHR pipelineBinaryKHR) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipelineBinaryKHR = pipelineBinaryKHR;

            
                  return *this;

            
                }

            
            #endif


                PipelineBinaryKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_pipelineBinaryKHR = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipelineBinaryKHR;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipelineBinaryKHR != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_pipelineBinaryKHR == VK_NULL_HANDLE;

            
                }


              private:

            
                VkPipelineBinaryKHR m_pipelineBinaryKHR = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkPipelineBinaryKHR, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueue.html

            
              class Queue

            
              {

            
              public:

            
                using CType = VkQueue;

            
                using NativeType = VkQueue;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;


              public:

            
                Queue() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Queue( Queue const & rhs ) = default;

            
                Queue & operator=( Queue const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Queue( Queue && rhs ) = default;

            
                Queue & operator=( Queue && rhs ) = default;

            
            #else

            
                Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_queue( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} ) )

            
                {}

            
                Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_queue = VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT

            
                  : m_queue( queue )

            
                {}


                Queue & operator=(VkQueue queue) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_queue = queue;

            
                  return *this;

            
                }


                Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_queue = {};

            
                  return *this;

            
                }


              //=== VK_VERSION_1_0 ===


                // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result submit( uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindSparse( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_3 ===


                // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result submit2( uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_swapchain ===


                // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_debug_utils ===


                // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void endDebugUtilsLabelEXT( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_device_diagnostic_checkpoints ===


                // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getCheckpointDataNV( uint32_t * pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html

            
                template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html

            
                template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getCheckpointData2NV( uint32_t * pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html

            
                template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html

            
                template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_INTEL_performance_query ===


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


              //=== VK_KHR_synchronization2 ===


                // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_low_latency2 ===


                // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                operator VkQueue() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_queue;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_queue != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_queue == VK_NULL_HANDLE;

            
                }


              private:

            
                VkQueue m_queue = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Queue;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Queue;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkQueue, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Queue;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevice.html

            
              class Device

            
              {

            
              public:

            
                using CType = VkDevice;

            
                using NativeType = VkDevice;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;


              public:

            
                Device() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Device( Device const & rhs ) = default;

            
                Device & operator=( Device const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Device( Device && rhs ) = default;

            
                Device & operator=( Device && rhs ) = default;

            
            #else

            
                Device( Device && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )

            
                {}

            
                Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_device = VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                Device( VkDevice device ) VULKAN_HPP_NOEXCEPT

            
                  : m_device( device )

            
                {}


                Device & operator=(VkDevice device) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_device = device;

            
                  return *this;

            
                }


                Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_device = {};

            
                  return *this;

            
                }


              //=== VK_VERSION_1_0 ===


                // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, VULKAN_HPP_NAMESPACE::Queue * pQueue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo * pAllocateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DeviceMemory * pMemory, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void ( free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void ( free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::MemoryMapFlags flags, void ** ppData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkInvalidateMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkInvalidateMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindImageMemory( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindImageMemory( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkGetBufferMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageSparseMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageSparseMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html

            
                template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetImageSparseMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html

            
                template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Fence * pFence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Fence fence, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Fence fence, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result resetFences( uint32_t fenceCount, const VULKAN_HPP_NAMESPACE::Fence * pFences, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result waitForFences( uint32_t fenceCount, const VULKAN_HPP_NAMESPACE::Fence * pFences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Semaphore * pSemaphore, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Event * pEvent, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyEvent( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyEvent( VULKAN_HPP_NAMESPACE::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Event event, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::QueryPool * pQueryPool, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void * pData, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html

            
                template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>> getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Buffer * pBuffer, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::BufferView * pView, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Image * pImage, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyImage( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyImage( VULKAN_HPP_NAMESPACE::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Image image, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout * pLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ImageView * pView, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ShaderModule * pShaderModule, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PipelineCache * pPipelineCache, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, size_t * pDataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PipelineLayout * pPipelineLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Sampler * pSampler, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorPool * pDescriptorPool, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo, VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html

            
                template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html

            
                template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>, typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>, typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Result ( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void ( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateDescriptorSets( uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, uint32_t descriptorCopyCount, const VULKAN_HPP_NAMESPACE::CopyDescriptorSet * pDescriptorCopies, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Framebuffer * pFramebuffer, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CommandPool * pCommandPool, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo, VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html

            
                template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html

            
                template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator & commandBufferAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>, typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>, typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator & commandBufferAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void ( free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool, uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void ( free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_1 ===


                // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetImageMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetBufferMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetBufferMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageSparseMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageSparseMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html

            
                template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetImageSparseMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html

            
                template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo, VULKAN_HPP_NAMESPACE::Queue * pQueue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUpdateDescriptorSetWithTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkUpdateDescriptorSetWithTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDescriptorSetLayoutSupport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDescriptorSetLayoutSupport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDescriptorSetLayoutSupport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_2 ===


                // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, uint64_t timeout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetBufferOpaqueCaptureAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferOpaqueCaptureAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_3 ===


                // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type createPrivateDataSlotUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceBufferMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceBufferMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDeviceBufferMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDeviceImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html

            
                template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html

            
                template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_4 ===


                // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result mapMemory2( const VULKAN_HPP_NAMESPACE::MemoryMapInfo * pMemoryMapInfo, void ** ppData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2( const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result unmapMemory2( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo * pMemoryUnmapInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type unmapMemory2( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetRenderingAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getRenderingAreaGranularity( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo * pRenderingAreaInfo, VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetRenderingAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderingAreaGranularity( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo * pInfo, VULKAN_HPP_NAMESPACE::SubresourceLayout2 * pLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDeviceImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSubresourceLayout2( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2 * pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout2 * pLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 getImageSubresourceLayout2( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayout2( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyMemoryToImage( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo * pCopyMemoryToImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type copyMemoryToImage( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyImageToMemory( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo * pCopyImageToMemoryInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type copyImageToMemory( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyImageToImage( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo * pCopyImageToImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type copyImageToImage( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result transitionImageLayout( uint32_t transitionCount, const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo * pTransitions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type transitionImageLayout( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_swapchain ===


                // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchain, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t * pSwapchainImageCount, VULKAN_HPP_NAMESPACE::Image * pSwapchainImages, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html

            
                template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename ImageAllocator::value_type, VULKAN_HPP_NAMESPACE::Image > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html

            
                template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename ImageAllocator::value_type, VULKAN_HPP_NAMESPACE::Image > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence, uint32_t * pImageIndex, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_display_swapchain ===


                // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t swapchainCount, const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html

            
                template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html

            
                template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, SwapchainKHRAllocator & swapchainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>, typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>, typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, SwapchainKHRAllocator & swapchainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_debug_marker ===


                // wrapper function for command vkDebugMarkerSetObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDebugMarkerSetObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDebugMarkerSetObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDebugMarkerSetObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_video_queue ===


                // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::VideoSessionKHR * pVideoSession, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, uint32_t * pMemoryRequirementsCount, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html

            
                template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html

            
                template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR * pVideoSessionParameters, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUpdateVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkUpdateVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NVX_binary_import ===


                // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CuModuleNVX * pModule, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CuFunctionNVX * pFunction, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NVX_image_view_handle ===


                // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getImageViewHandle64NVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getImageViewHandle64NVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_AMD_shader_info ===


                // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, size_t * pInfoSize, void * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_NV_external_memory_win32 ===


                // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, HANDLE * pHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_KHR_device_group ===


                // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_maintenance1 ===


                // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_external_memory_win32 ===


                // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_KHR_external_memory_fd ===


                // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo, int * pFd, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR * pMemoryFdProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_external_semaphore_win32 ===


                // wrapper function for command vkImportSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkImportSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_KHR_external_semaphore_fd ===


                // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_descriptor_update_template ===


                // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_display_control ===


                // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT * pDeviceEventInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Fence * pFence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Fence * pFence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, uint64_t * pCounterValue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_GOOGLE_display_timing ===


                // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPastPresentationTimingGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t * pPresentationTimingCount, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPastPresentationTimingGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html

            
                template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPastPresentationTimingGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html

            
                template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_hdr_metadata ===


                // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setHdrMetadataEXT( uint32_t swapchainCount, const VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_create_renderpass2 ===


                // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_shared_presentable_image ===


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_external_fence_win32 ===


                // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_KHR_external_fence_fd ===


                // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo, int * pFd, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_performance_query ===


                // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void releaseProfilingLockKHR( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_debug_utils ===


                // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_ANDROID_KHR )

            
              //=== VK_ANDROID_external_memory_android_hardware_buffer ===


                // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo, struct AHardwareBuffer ** pBuffer, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_AMDX_shader_enqueue ===


                // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createExecutionGraphPipelineAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createExecutionGraphPipelinesAMDXUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createExecutionGraphPipelinesAMDXUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createExecutionGraphPipelineAMDXUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX>::type getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo, uint32_t * pNodeIndex, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


              //=== VK_KHR_get_memory_requirements2 ===


                // wrapper function for command vkGetImageMemoryRequirements2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageMemoryRequirements2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetImageMemoryRequirements2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetBufferMemoryRequirements2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferMemoryRequirements2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetBufferMemoryRequirements2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html

            
                template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html

            
                template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_acceleration_structure ===


                // wrapper function for command vkCreateAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructure, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkBuildAccelerationStructuresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBuildAccelerationStructuresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void * pData, size_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html

            
                template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeAccelerationStructuresPropertiesKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeAccelerationStructuresPropertyKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo, const uint32_t * pMaxPrimitiveCounts, VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR * pSizeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_ray_tracing_pipeline ===


                // wrapper function for command vkCreateRayTracingPipelinesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateRayTracingPipelinesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateRayTracingPipelinesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateRayTracingPipelinesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateRayTracingPipelinesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateRayTracingPipelinesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateRayTracingPipelinesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html

            
                template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html

            
                template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_sampler_ycbcr_conversion ===


                // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_bind_memory2 ===


                // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_image_drm_format_modifier ===


                // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_validation_cache ===


                // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pValidationCache, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, size_t * pDataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_ray_tracing ===


                // wrapper function for command vkCreateAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkBindAccelerationStructureMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindAccelerationStructureMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindAccelerationStructureMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateRayTracingPipelinesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateRayTracingPipelinesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateRayTracingPipelinesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html

            
                template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateRayTracingPipelinesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateRayTracingPipelinesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateRayTracingPipelinesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateRayTracingPipelinesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html

            
                template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetAccelerationStructureHandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetAccelerationStructureHandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html

            
                template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetAccelerationStructureHandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


              //=== VK_KHR_maintenance3 ===


                // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_external_memory_host ===


                // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_calibrated_timestamps ===


                // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t timestampCount, const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos, uint64_t * pTimestamps, uint64_t * pMaxDeviation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html

            
                template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html

            
                template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos, Uint64_tAllocator & uint64_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_timeline_semaphore ===


                // wrapper function for command vkGetSemaphoreCounterValueKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetSemaphoreCounterValueKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, uint64_t timeout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_INTEL_performance_query ===


                // wrapper function for command vkInitializePerformanceApiINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkInitializePerformanceApiINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUninitializePerformanceApiINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void uninitializePerformanceApiINTEL( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


                // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL * pConfiguration, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkReleasePerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkReleasePerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkReleasePerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkReleasePerformanceConfigurationINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkGetPerformanceParameterINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, VULKAN_HPP_NAMESPACE::PerformanceValueINTEL * pValue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPerformanceParameterINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_AMD_display_native_hdr ===


                // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain, VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_EXT_buffer_device_address ===


                // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_present_wait ===


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_EXT_full_screen_exclusive ===


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_KHR_buffer_device_address ===


                // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_host_query_reset ===


                // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_deferred_host_operations ===


                // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DeferredOperationKHR * pDeferredOperation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeferredOperationResultKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkGetDeferredOperationResultKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


              //=== VK_KHR_pipeline_executable_properties ===


                // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo, uint32_t * pExecutableCount, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html

            
                template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html

            
                template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo, PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, uint32_t * pStatisticCount, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR * pStatistics, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html

            
                template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html

            
                template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, uint32_t * pInternalRepresentationCount, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html

            
                template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html

            
                template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_host_image_copy ===


                // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo * pCopyMemoryToImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo * pCopyImageToMemoryInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo * pCopyImageToImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t transitionCount, const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo * pTransitions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageSubresourceLayout2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2 * pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout2 * pLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageSubresourceLayout2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetImageSubresourceLayout2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_map_memory2 ===


                // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfo * pMemoryMapInfo, void ** ppData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo * pMemoryUnmapInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_swapchain_maintenance1 ===


                // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT * pReleaseInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_device_generated_commands ===


                // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV * pIndirectCommandsLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_private_data ===


                // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_video_encode_queue ===


                // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, size_t * pDataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html

            
                template <typename X, typename Y, typename... Z, typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html

            
                template <typename X, typename Y, typename... Z, typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_ENABLE_BETA_EXTENSIONS )

            
              //=== VK_NV_cuda_kernel_launch ===


                // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CudaModuleNV * pModule, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaModuleNV>::type createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaModuleNV, Dispatch>>::type createCudaModuleNVUnique( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, size_t * pCacheSize, void * pCacheData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CudaFunctionNV * pFunction, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>::type createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaFunctionNV, Dispatch>>::type createCudaFunctionNVUnique( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV function, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV function, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_ENABLE_BETA_EXTENSIONS*/


            #if defined( VK_USE_PLATFORM_METAL_EXT )

            
              //=== VK_EXT_metal_objects ===


                // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_METAL_EXT*/


              //=== VK_EXT_descriptor_buffer ===


                // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, VULKAN_HPP_NAMESPACE::DeviceSize * pLayoutSizeInBytes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, VULKAN_HPP_NAMESPACE::DeviceSize * pOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html

            
                template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_device_fault ===


                // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT * pFaultInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_external_memory ===


                // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, zx_handle_t * pZirconHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_external_semaphore ===


                // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, zx_handle_t * pZirconHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_buffer_collection ===


                // wrapper function for command vkCreateBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA * pCollection, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


              //=== VK_HUAWEI_subpass_shading ===


                // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Extent2D>::type getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_external_memory_rdma ===


                // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, VULKAN_HPP_NAMESPACE::RemoteAddressNV * pAddress, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_pipeline_properties ===


                // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT * pPipelineInfo, VULKAN_HPP_NAMESPACE::BaseOutStructure * pPipelineProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BaseOutStructure>::type getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_opacity_micromap ===


                // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromap, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MicromapEXT>::type createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>>::type createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkWriteMicromapsPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void * pData, size_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkWriteMicromapsPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html

            
                template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DataTypeAllocator::value_type, DataType > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkWriteMicromapsPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT * pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pBuildInfo, VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT * pSizeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_pageable_device_local_memory ===


                // wrapper function for command vkSetDeviceMemoryPriorityEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory, float priority, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;


              //=== VK_KHR_maintenance4 ===


                // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html

            
                template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html

            
                template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VALVE_descriptor_set_host_mapping ===


                // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, void ** ppData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_device_generated_commands_compute ===


                // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_ARM_tensors ===


                // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createTensorARM( const VULKAN_HPP_NAMESPACE::TensorCreateInfoARM * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::TensorARM * pTensor, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::TensorARM>::type createTensorARM( const VULKAN_HPP_NAMESPACE::TensorCreateInfoARM & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::TensorARM, Dispatch>>::type createTensorARMUnique( const VULKAN_HPP_NAMESPACE::TensorCreateInfoARM & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyTensorARM( VULKAN_HPP_NAMESPACE::TensorARM tensor, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyTensorARM( VULKAN_HPP_NAMESPACE::TensorARM tensor VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::TensorARM tensor, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::TensorARM tensor, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createTensorViewARM( const VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::TensorViewARM * pView, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::TensorViewARM>::type createTensorViewARM( const VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::TensorViewARM, Dispatch>>::type createTensorViewARMUnique( const VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyTensorViewARM( VULKAN_HPP_NAMESPACE::TensorViewARM tensorView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyTensorViewARM( VULKAN_HPP_NAMESPACE::TensorViewARM tensorView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::TensorViewARM tensorView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::TensorViewARM tensorView, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetTensorMemoryRequirementsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getTensorMemoryRequirementsARM( const VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetTensorMemoryRequirementsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getTensorMemoryRequirementsARM( const VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetTensorMemoryRequirementsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getTensorMemoryRequirementsARM( const VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindTensorMemoryARM( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindTensorMemoryARM( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getTensorMemoryRequirementsARM( const VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getTensorMemoryRequirementsARM( const VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getTensorMemoryRequirementsARM( const VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getTensorOpaqueCaptureDescriptorDataARM( const VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getTensorOpaqueCaptureDescriptorDataARM( const VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getTensorViewOpaqueCaptureDescriptorDataARM( const VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html

            
                template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getTensorViewOpaqueCaptureDescriptorDataARM( const VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_shader_module_identifier ===


                // wrapper function for command vkGetShaderModuleIdentifierEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetShaderModuleIdentifierEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_optical_flow ===


                // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV * pSession, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>::type createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>>::type createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkBindOpticalFlowSessionImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, VULKAN_HPP_NAMESPACE::ImageLayout layout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkBindOpticalFlowSessionImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, VULKAN_HPP_NAMESPACE::ImageLayout layout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


              //=== VK_KHR_maintenance5 ===


                // wrapper function for command vkGetRenderingAreaGranularityKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo * pRenderingAreaInfo, VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetRenderingAreaGranularityKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo * pInfo, VULKAN_HPP_NAMESPACE::SubresourceLayout2 * pLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetImageSubresourceLayout2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2 * pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout2 * pLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetImageSubresourceLayout2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetImageSubresourceLayout2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_AMD_anti_lag ===


                // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void antiLagUpdateAMD( const VULKAN_HPP_NAMESPACE::AntiLagDataAMD * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void antiLagUpdateAMD( const VULKAN_HPP_NAMESPACE::AntiLagDataAMD & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_present_wait2 ===


                // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result waitForPresent2KHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR * pPresentWait2Info, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresent2KHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR & presentWait2Info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_shader_object ===


                // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html

            
                template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>> createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html

            
                template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>> createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, ShaderEXTAllocator & shaderEXTAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::ShaderEXT> createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>, typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>> createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>, typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>> createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, ShaderEXTAllocator & shaderEXTAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>> createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, size_t * pDataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_pipeline_binary ===


                // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR * pBinaries, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html

            
                template <typename PipelineBinaryKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineBinaryKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>> createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html

            
                template <typename PipelineBinaryKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineBinaryKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>> createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>> createPipelineBinariesKHRUnique( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>>, typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch> > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>> createPipelineBinariesKHRUnique( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineBinaryKHRAllocator & pipelineBinaryKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPipelineBinaryKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyPipelineBinaryKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPipelineKeyKHR( const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR * pPipelineCreateInfo, VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR * pPipelineKey, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR>::type getPipelineKeyKHR( Optional<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> pipelineCreateInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR * pInfo, VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR * pPipelineBinaryKey, size_t * pPipelineBinaryDataSize, void * pPipelineBinaryData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html

            
                template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkReleaseCapturedPipelineDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Result releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR * pInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkReleaseCapturedPipelineDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR & info, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_QCOM_tile_properties ===


                // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, uint32_t * pPropertiesCount, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html

            
                template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html

            
                template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, TilePropertiesQCOMAllocator & tilePropertiesQCOMAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Result getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_cooperative_vector ===


                // wrapper function for command vkConvertCooperativeVectorMatrixNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkConvertCooperativeVectorMatrixNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result convertCooperativeVectorMatrixNV( const VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_low_latency2 ===


                // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Result latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html

            
                template <typename LatencyTimingsFrameReportNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename LatencyTimingsFrameReportNVAllocator::value_type, VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator> getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html

            
                template <typename LatencyTimingsFrameReportNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename LatencyTimingsFrameReportNVAllocator::value_type, VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator> getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, LatencyTimingsFrameReportNVAllocator & latencyTimingsFrameReportNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_SCREEN_QNX )

            
              //=== VK_QNX_external_memory_screen_buffer ===


                // wrapper function for command vkGetScreenBufferPropertiesQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetScreenBufferPropertiesQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>::type getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetScreenBufferPropertiesQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_SCREEN_QNX*/


              //=== VK_KHR_calibrated_timestamps ===


                // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t timestampCount, const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos, uint64_t * pTimestamps, uint64_t * pMaxDeviation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html

            
                template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html

            
                template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos, Uint64_tAllocator & uint64_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_external_compute_queue ===


                // wrapper function for command vkCreateExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV * pExternalQueue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>::type createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV, Dispatch>>::type createExternalComputeQueueNVUnique( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_cluster_acceleration_structure ===


                // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getClusterAccelerationStructureBuildSizesNV( const VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV * pInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR * pSizeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getClusterAccelerationStructureBuildSizesNV( const VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_partitioned_acceleration_structure ===


                // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getPartitionedAccelerationStructuresBuildSizesNV( const VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV * pInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR * pSizeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getPartitionedAccelerationStructuresBuildSizesNV( const VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_device_generated_commands ===


                // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getGeneratedCommandsMemoryRequirementsEXT( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsEXT( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsEXT( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutEXT( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT * pIndirectCommandsLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT>::type createIndirectCommandsLayoutEXT( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT, Dispatch>>::type createIndirectCommandsLayoutEXTUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyIndirectCommandsLayoutEXT( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyIndirectCommandsLayoutEXT( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT indirectCommandsLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createIndirectExecutionSetEXT( const VULKAN_HPP_NAMESPACE::IndirectExecutionSetCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT * pIndirectExecutionSet, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT>::type createIndirectExecutionSetEXT( const VULKAN_HPP_NAMESPACE::IndirectExecutionSetCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT, Dispatch>>::type createIndirectExecutionSetEXTUnique( const VULKAN_HPP_NAMESPACE::IndirectExecutionSetCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyIndirectExecutionSetEXT( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyIndirectExecutionSetEXT( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateIndirectExecutionSetPipelineEXT( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateIndirectExecutionSetPipelineEXT( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT> const & executionSetWrites, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateIndirectExecutionSetShaderEXT( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT * pExecutionSetWrites, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void updateIndirectExecutionSetShaderEXT( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT> const & executionSetWrites, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_METAL_EXT )

            
              //=== VK_EXT_external_memory_metal ===


                // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryMetalHandleEXT( const VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo, void ** pHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type getMemoryMetalHandleEXT( const VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT & getMetalHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getMemoryMetalHandlePropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHandle, VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html

            
                template <typename HandleType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>::type getMemoryMetalHandlePropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_METAL_EXT*/


                operator VkDevice() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_device;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_device != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_device == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDevice m_device = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Device;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Device;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDevice, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Device;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeKHR.html

            
              class DisplayModeKHR

            
              {

            
              public:

            
                using CType = VkDisplayModeKHR;

            
                using NativeType = VkDisplayModeKHR;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;


              public:

            
                DisplayModeKHR() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                DisplayModeKHR( DisplayModeKHR const & rhs ) = default;

            
                DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                DisplayModeKHR( DisplayModeKHR && rhs ) = default;

            
                DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default;

            
            #else

            
                DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_displayModeKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) )

            
                {}

            
                DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_displayModeKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT

            
                  : m_displayModeKHR( displayModeKHR )

            
                {}


            #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )

            
                DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_displayModeKHR = displayModeKHR;

            
                  return *this;

            
                }

            
            #endif


                DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_displayModeKHR = {};

            
                  return *this;

            
                }


                VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_displayModeKHR;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_displayModeKHR != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_displayModeKHR == VK_NULL_HANDLE;

            
                }


              private:

            
                VkDisplayModeKHR m_displayModeKHR = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkDisplayModeKHR, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkPhysicalDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice.html

            
              class PhysicalDevice

            
              {

            
              public:

            
                using CType = VkPhysicalDevice;

            
                using NativeType = VkPhysicalDevice;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;


              public:

            
                PhysicalDevice() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                PhysicalDevice( PhysicalDevice const & rhs ) = default;

            
                PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                PhysicalDevice( PhysicalDevice && rhs ) = default;

            
                PhysicalDevice & operator=( PhysicalDevice && rhs ) = default;

            
            #else

            
                PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )

            
                {}

            
                PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_physicalDevice = VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT

            
                  : m_physicalDevice( physicalDevice )

            
                {}


                PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_physicalDevice = physicalDevice;

            
                  return *this;

            
                }


                PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_physicalDevice = {};

            
                  return *this;

            
                }


              //=== VK_VERSION_1_0 ===


                // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html

            
                template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html

            
                template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Device * pDevice, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkEnumerateDeviceExtensionProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char * pLayerName, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEnumerateDeviceExtensionProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html

            
                template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkEnumerateDeviceExtensionProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html

            
                template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName, ExtensionPropertiesAllocator & extensionPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkEnumerateDeviceLayerProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEnumerateDeviceLayerProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html

            
                template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkEnumerateDeviceLayerProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html

            
                template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html

            
                template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html

            
                template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_1 ===


                // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetPhysicalDeviceProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html

            
                template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html

            
                template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html

            
                template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html

            
                template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_3 ===


                // wrapper function for command vkGetPhysicalDeviceToolProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t * pToolCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceToolProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html

            
                template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceToolProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html

            
                template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_surface ===


                // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::Bool32 * pSupported, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t * pSurfaceFormatCount, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html

            
                template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html

            
                template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t * pPresentModeCount, VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html

            
                template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html

            
                template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_swapchain ===


                // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t * pRectCount, VULKAN_HPP_NAMESPACE::Rect2D * pRects, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html

            
                template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, VULKAN_HPP_NAMESPACE::Rect2D > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html

            
                template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, VULKAN_HPP_NAMESPACE::Rect2D > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_display ===


                // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html

            
                template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html

            
                template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html

            
                template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html

            
                template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t * pDisplayCount, VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html

            
                template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html

            
                template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDisplayModePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDisplayModePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html

            
                template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetDisplayModePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html

            
                template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DisplayModeKHR * pMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_XLIB_KHR )

            
              //=== VK_KHR_xlib_surface ===


                // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display * dpy, VisualID visualID, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_XLIB_KHR*/


            #if defined( VK_USE_PLATFORM_XCB_KHR )

            
              //=== VK_KHR_xcb_surface ===


                // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t * connection, xcb_visualid_t visual_id, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_XCB_KHR*/


            #if defined( VK_USE_PLATFORM_WAYLAND_KHR )

            
              //=== VK_KHR_wayland_surface ===


                // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display * display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_win32_surface ===


                // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_KHR_video_queue ===


                // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile, VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR * pCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, uint32_t * pVideoFormatPropertyCount, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR * pVideoFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html

            
                template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html

            
                template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_external_memory_capabilities ===


                // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType, VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_get_physical_device_properties2 ===


                // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html

            
                template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html

            
                template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
                // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html

            
                template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html

            
                template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_external_memory_capabilities ===


                // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_external_semaphore_capabilities ===


                // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_direct_mode_display ===


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


            #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )

            
              //=== VK_EXT_acquire_xlib_display ===


                // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display * dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display * dpy, RROutput rrOutput, VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/


              //=== VK_EXT_display_surface_counter ===


                // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_external_fence_capabilities ===


                // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_performance_query ===


                // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, uint32_t * pCounterCount, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR * pCounters, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html

            
                template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PerformanceCounterKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR > ::value  && std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html

            
                template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PerformanceCounterKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR > ::value  && std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, PerformanceCounterKHRAllocator & performanceCounterKHRAllocator, PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, uint32_t * pNumPasses, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_get_surface_capabilities2 ===


                // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR * pSurfaceCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pSurfaceFormatCount, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html

            
                template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html

            
                template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_get_display_properties2 ===


                // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html

            
                template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html

            
                template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html

            
                template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html

            
                template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDisplayModeProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDisplayModeProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html

            
                template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetDisplayModeProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html

            
                template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetDisplayModeProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetDisplayModeProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html

            
                template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR * pDisplayPlaneInfo, VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_sample_locations ===


                // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_calibrated_timestamps ===


                // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html

            
                template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html

            
                template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_fragment_shading_rate ===


                // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html

            
                template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html

            
                template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_EXT_tooling_info ===


                // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t * pToolCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html

            
                template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html

            
                template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_cooperative_matrix ===


                // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html

            
                template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html

            
                template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_coverage_reduction_mode ===


                // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t * pCombinationCount, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html

            
                template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html

            
                template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_EXT_full_screen_exclusive ===


                // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pPresentModeCount, VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html

            
                template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html

            
                template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_EXT_acquire_drm_display ===


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                typename ResultValueType<void>::type acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, VULKAN_HPP_NAMESPACE::DisplayKHR * display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_video_encode_queue ===


                // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>::type getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html

            
                template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_NV_acquire_winrt_display ===


            #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #else

            
                // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/


                // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId, VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


            #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )

            
              //=== VK_EXT_directfb_surface ===


                // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB * dfb, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/


            #if defined( VK_USE_PLATFORM_SCREEN_QNX )

            
              //=== VK_QNX_screen_surface ===


                // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window * window, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_SCREEN_QNX*/


              //=== VK_ARM_tensors ===


                // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void getExternalTensorPropertiesARM( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo, VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM * pExternalTensorProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM getExternalTensorPropertiesARM( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM & externalTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_optical_flow ===


                // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, uint32_t * pFormatCount, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html

            
                template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html

            
                template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, OpticalFlowImageFormatPropertiesNVAllocator & opticalFlowImageFormatPropertiesNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_cooperative_vector ===


                // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getCooperativeVectorPropertiesNV( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html

            
                template <typename CooperativeVectorPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CooperativeVectorPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator>>::type getCooperativeVectorPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html

            
                template <typename CooperativeVectorPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CooperativeVectorPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV, CooperativeVectorPropertiesNVAllocator>>::type getCooperativeVectorPropertiesNV( CooperativeVectorPropertiesNVAllocator & cooperativeVectorPropertiesNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_cooperative_matrix ===


                // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html

            
                template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html

            
                template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_calibrated_timestamps ===


                // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount, VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html

            
                template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html

            
                template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_NV_cooperative_matrix2 ===


                // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result getCooperativeMatrixFlexibleDimensionsPropertiesNV( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html

            
                template <typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator>>::type getCooperativeMatrixFlexibleDimensionsPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html

            
                template <typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV, CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator>>::type getCooperativeMatrixFlexibleDimensionsPropertiesNV( CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator & cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_physicalDevice;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_physicalDevice != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_physicalDevice == VK_NULL_HANDLE;

            
                }


              private:

            
                VkPhysicalDevice m_physicalDevice = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkPhysicalDevice, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              // wrapper class for handle VkInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstance.html

            
              class Instance

            
              {

            
              public:

            
                using CType = VkInstance;

            
                using NativeType = VkInstance;


                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;


              public:

            
                Instance() VULKAN_HPP_NOEXCEPT {}    // = default; - try to workaround a compiler issue

            
                Instance( Instance const & rhs ) = default;

            
                Instance & operator=( Instance const & rhs ) = default;


            #if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)

            
                Instance( Instance && rhs ) = default;

            
                Instance & operator=( Instance && rhs ) = default;

            
            #else

            
                Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT

            
                  : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) )

            
                {}

            
                Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_instance = VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} );

            
                  return *this;

            
                }

            
            #endif


                VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {}

            
                Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT

            
                  : m_instance( instance )

            
                {}


                Instance & operator=(VkInstance instance) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_instance = instance;

            
                  return *this;

            
                }


                Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT

            
                {

            
                  m_instance = {};

            
                  return *this;

            
                }


              //=== VK_VERSION_1_0 ===


                // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount, VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html

            
                template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html

            
                template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NAMESPACE::PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_1 ===


                // wrapper function for command vkEnumeratePhysicalDeviceGroups, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEnumeratePhysicalDeviceGroups, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html

            
                template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkEnumeratePhysicalDeviceGroups, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html

            
                template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_surface ===


                // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_KHR_display ===


                // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_XLIB_KHR )

            
              //=== VK_KHR_xlib_surface ===


                // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_XLIB_KHR*/


            #if defined( VK_USE_PLATFORM_XCB_KHR )

            
              //=== VK_KHR_xcb_surface ===


                // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_XCB_KHR*/


            #if defined( VK_USE_PLATFORM_WAYLAND_KHR )

            
              //=== VK_KHR_wayland_surface ===


                // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/


            #if defined( VK_USE_PLATFORM_ANDROID_KHR )

            
              //=== VK_KHR_android_surface ===


                // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_ANDROID_KHR*/


            #if defined( VK_USE_PLATFORM_WIN32_KHR )

            
              //=== VK_KHR_win32_surface ===


                // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_WIN32_KHR*/


              //=== VK_EXT_debug_report ===


                // wrapper function for command vkCreateDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT * pCallback, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char * pLayerPrefix, const char * pMessage, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_GGP )

            
              //=== VK_GGP_stream_descriptor_surface ===


                // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createStreamDescriptorSurfaceGGPUnique( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_GGP*/


            #if defined( VK_USE_PLATFORM_VI_NN )

            
              //=== VK_NN_vi_surface ===


                // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_VI_NN*/


              //=== VK_KHR_device_group_creation ===


                // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html

            
                template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
                // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html

            
                template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_IOS_MVK )

            
              //=== VK_MVK_ios_surface ===


                // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_IOS_MVK*/


            #if defined( VK_USE_PLATFORM_MACOS_MVK )

            
              //=== VK_MVK_macos_surface ===


                // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_MACOS_MVK*/


              //=== VK_EXT_debug_utils ===


                // wrapper function for command vkCreateDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT * pMessenger, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkSubmitDebugUtilsMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkSubmitDebugUtilsMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_FUCHSIA )

            
              //=== VK_FUCHSIA_imagepipe_surface ===


                // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_FUCHSIA*/


            #if defined( VK_USE_PLATFORM_METAL_EXT )

            
              //=== VK_EXT_metal_surface ===


                // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_METAL_EXT*/


              //=== VK_EXT_headless_surface ===


                // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


            #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )

            
              //=== VK_EXT_directfb_surface ===


                // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/


            #if defined( VK_USE_PLATFORM_SCREEN_QNX )

            
              //=== VK_QNX_screen_surface ===


                // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

            
            #endif /*VK_USE_PLATFORM_SCREEN_QNX*/


                operator VkInstance() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_instance;

            
                }


                explicit operator bool() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_instance != VK_NULL_HANDLE;

            
                }


                bool operator!() const VULKAN_HPP_NOEXCEPT

            
                {

            
                  return m_instance == VK_NULL_HANDLE;

            
                }


              private:

            
                VkInstance m_instance = {};

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Instance;

            
              };


              template <>

            
              struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Instance;

            
              };


            #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )

            
              template <>

            
              struct CppType<VkInstance, VK_NULL_HANDLE>

            
              {

            
                using Type = VULKAN_HPP_NAMESPACE::Instance;

            
              };

            
            #endif


              template <>

            
              struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>

            
              {

            
                static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;

            
              };


              //=== VK_VERSION_1_0 ===


                // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Instance * pInstance, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

            
            #  ifndef VULKAN_HPP_NO_SMART_HANDLE

            
                // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

            
            #  endif /* VULKAN_HPP_NO_SMART_HANDLE */

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkEnumerateInstanceExtensionProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char * pLayerName, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEnumerateInstanceExtensionProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html

            
                template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

            
                // wrapper function for command vkEnumerateInstanceExtensionProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html

            
                template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, ExtensionPropertiesAllocator & extensionPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


                // wrapper function for command vkEnumerateInstanceLayerProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEnumerateInstanceLayerProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html

            
                template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

            
                // wrapper function for command vkEnumerateInstanceLayerProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html

            
                template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties > ::value , int>::type = 0>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              //=== VK_VERSION_1_1 ===


                // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t * pApiVersion, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;

            
            #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE

            
                // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html

            
                template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

            
                VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );

            
            #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */


              // operators to compare VULKAN_HPP_NAMESPACE::-handles

            
            #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )

            
              template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>

            
              auto operator<=>( T const & lhs, T const & rhs )

            
              {

            
                return static_cast<typename T::NativeType>( lhs ) <=> static_cast<typename T::NativeType>( rhs );

            
              }

            
            #else

            
              template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>

            
              bool operator==( T const & lhs, T const & rhs )

            
              {

            
                return static_cast<typename T::NativeType>( lhs ) == static_cast<typename T::NativeType>( rhs );

            
              }


              template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>

            
              bool operator!=( T const & lhs, T const & rhs )

            
              {

            
                return static_cast<typename T::NativeType>( lhs ) != static_cast<typename T::NativeType>( rhs );

            
              }


              template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>

            
              bool operator<( T const & lhs, T const & rhs )

            
              {

            
                return static_cast<typename T::NativeType>( lhs ) < static_cast<typename T::NativeType>( rhs );

            
              }

            
            #endif


              template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>

            
              bool operator==( T const & v, std::nullptr_t )

            
              {

            
                return !v;

            
              }


              template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>

            
              bool operator==( std::nullptr_t, T const & v )

            
              {

            
                return !v;

            
              }


              template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>

            
              bool operator!=( T const & v, std::nullptr_t )

            
              {

            
                return !!v;

            
              }


              template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>

            
              bool operator!=( std::nullptr_t, T const & v )

            
              {

            
                return !!v;

            
              }

            
            }   // namespace VULKAN_HPP_NAMESPACE

            
            #endif