1// Copyright 2015-2024 The Khronos Group Inc.
2//
3// SPDX-License-Identifier: Apache-2.0 OR MIT
4//
5
6// This header is generated from the Khronos Vulkan XML API Registry.
7
8#ifndef VULKAN_HANDLES_HPP
9#define VULKAN_HANDLES_HPP
10
11namespace VULKAN_HPP_NAMESPACE
12{
13
14  //===================================
15  //=== STRUCT forward declarations ===
16  //===================================
17
18  //=== VK_VERSION_1_0 ===
19  struct Extent2D;
20  struct Extent3D;
21  struct Offset2D;
22  struct Offset3D;
23  struct Rect2D;
24  struct BaseInStructure;
25  struct BaseOutStructure;
26  struct BufferMemoryBarrier;
27  struct DispatchIndirectCommand;
28  struct DrawIndexedIndirectCommand;
29  struct DrawIndirectCommand;
30  struct ImageMemoryBarrier;
31  struct MemoryBarrier;
32  struct PipelineCacheHeaderVersionOne;
33  struct AllocationCallbacks;
34  struct ApplicationInfo;
35  struct FormatProperties;
36  struct ImageFormatProperties;
37  struct InstanceCreateInfo;
38  struct MemoryHeap;
39  struct MemoryType;
40  struct PhysicalDeviceFeatures;
41  struct PhysicalDeviceLimits;
42  struct PhysicalDeviceMemoryProperties;
43  struct PhysicalDeviceProperties;
44  struct PhysicalDeviceSparseProperties;
45  struct QueueFamilyProperties;
46  struct DeviceCreateInfo;
47  struct DeviceQueueCreateInfo;
48  struct ExtensionProperties;
49  struct LayerProperties;
50  struct SubmitInfo;
51  struct MappedMemoryRange;
52  struct MemoryAllocateInfo;
53  struct MemoryRequirements;
54  struct BindSparseInfo;
55  struct ImageSubresource;
56  struct SparseBufferMemoryBindInfo;
57  struct SparseImageFormatProperties;
58  struct SparseImageMemoryBind;
59  struct SparseImageMemoryBindInfo;
60  struct SparseImageMemoryRequirements;
61  struct SparseImageOpaqueMemoryBindInfo;
62  struct SparseMemoryBind;
63  struct FenceCreateInfo;
64  struct SemaphoreCreateInfo;
65  struct EventCreateInfo;
66  struct QueryPoolCreateInfo;
67  struct BufferCreateInfo;
68  struct BufferViewCreateInfo;
69  struct ImageCreateInfo;
70  struct SubresourceLayout;
71  struct ComponentMapping;
72  struct ImageSubresourceRange;
73  struct ImageViewCreateInfo;
74  struct ShaderModuleCreateInfo;
75  struct PipelineCacheCreateInfo;
76  struct ComputePipelineCreateInfo;
77  struct GraphicsPipelineCreateInfo;
78  struct PipelineColorBlendAttachmentState;
79  struct PipelineColorBlendStateCreateInfo;
80  struct PipelineDepthStencilStateCreateInfo;
81  struct PipelineDynamicStateCreateInfo;
82  struct PipelineInputAssemblyStateCreateInfo;
83  struct PipelineMultisampleStateCreateInfo;
84  struct PipelineRasterizationStateCreateInfo;
85  struct PipelineShaderStageCreateInfo;
86  struct PipelineTessellationStateCreateInfo;
87  struct PipelineVertexInputStateCreateInfo;
88  struct PipelineViewportStateCreateInfo;
89  struct SpecializationInfo;
90  struct SpecializationMapEntry;
91  struct StencilOpState;
92  struct VertexInputAttributeDescription;
93  struct VertexInputBindingDescription;
94  struct Viewport;
95  struct PipelineLayoutCreateInfo;
96  struct PushConstantRange;
97  struct SamplerCreateInfo;
98  struct CopyDescriptorSet;
99  struct DescriptorBufferInfo;
100  struct DescriptorImageInfo;
101  struct DescriptorPoolCreateInfo;
102  struct DescriptorPoolSize;
103  struct DescriptorSetAllocateInfo;
104  struct DescriptorSetLayoutBinding;
105  struct DescriptorSetLayoutCreateInfo;
106  struct WriteDescriptorSet;
107  struct AttachmentDescription;
108  struct AttachmentReference;
109  struct FramebufferCreateInfo;
110  struct RenderPassCreateInfo;
111  struct SubpassDependency;
112  struct SubpassDescription;
113  struct CommandPoolCreateInfo;
114  struct CommandBufferAllocateInfo;
115  struct CommandBufferBeginInfo;
116  struct CommandBufferInheritanceInfo;
117  struct BufferCopy;
118  struct BufferImageCopy;
119  struct ClearAttachment;
120  union ClearColorValue;
121  struct ClearDepthStencilValue;
122  struct ClearRect;
123  union ClearValue;
124  struct ImageBlit;
125  struct ImageCopy;
126  struct ImageResolve;
127  struct ImageSubresourceLayers;
128  struct RenderPassBeginInfo;
129
130  //=== VK_VERSION_1_1 ===
131  struct PhysicalDeviceSubgroupProperties;
132  struct BindBufferMemoryInfo;
133  using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
134  struct BindImageMemoryInfo;
135  using BindImageMemoryInfoKHR = BindImageMemoryInfo;
136  struct PhysicalDevice16BitStorageFeatures;
137  using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
138  struct MemoryDedicatedRequirements;
139  using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
140  struct MemoryDedicatedAllocateInfo;
141  using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
142  struct MemoryAllocateFlagsInfo;
143  using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
144  struct DeviceGroupRenderPassBeginInfo;
145  using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
146  struct DeviceGroupCommandBufferBeginInfo;
147  using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
148  struct DeviceGroupSubmitInfo;
149  using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
150  struct DeviceGroupBindSparseInfo;
151  using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
152  struct BindBufferMemoryDeviceGroupInfo;
153  using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
154  struct BindImageMemoryDeviceGroupInfo;
155  using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
156  struct PhysicalDeviceGroupProperties;
157  using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
158  struct DeviceGroupDeviceCreateInfo;
159  using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
160  struct BufferMemoryRequirementsInfo2;
161  using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
162  struct ImageMemoryRequirementsInfo2;
163  using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
164  struct ImageSparseMemoryRequirementsInfo2;
165  using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
166  struct MemoryRequirements2;
167  using MemoryRequirements2KHR = MemoryRequirements2;
168  struct SparseImageMemoryRequirements2;
169  using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
170  struct PhysicalDeviceFeatures2;
171  using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
172  struct PhysicalDeviceProperties2;
173  using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
174  struct FormatProperties2;
175  using FormatProperties2KHR = FormatProperties2;
176  struct ImageFormatProperties2;
177  using ImageFormatProperties2KHR = ImageFormatProperties2;
178  struct PhysicalDeviceImageFormatInfo2;
179  using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
180  struct QueueFamilyProperties2;
181  using QueueFamilyProperties2KHR = QueueFamilyProperties2;
182  struct PhysicalDeviceMemoryProperties2;
183  using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
184  struct SparseImageFormatProperties2;
185  using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
186  struct PhysicalDeviceSparseImageFormatInfo2;
187  using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
188  struct PhysicalDevicePointClippingProperties;
189  using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
190  struct RenderPassInputAttachmentAspectCreateInfo;
191  using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
192  struct InputAttachmentAspectReference;
193  using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
194  struct ImageViewUsageCreateInfo;
195  using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
196  struct PipelineTessellationDomainOriginStateCreateInfo;
197  using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
198  struct RenderPassMultiviewCreateInfo;
199  using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
200  struct PhysicalDeviceMultiviewFeatures;
201  using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
202  struct PhysicalDeviceMultiviewProperties;
203  using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
204  struct PhysicalDeviceVariablePointersFeatures;
205  using PhysicalDeviceVariablePointerFeatures     = PhysicalDeviceVariablePointersFeatures;
206  using PhysicalDeviceVariablePointerFeaturesKHR  = PhysicalDeviceVariablePointersFeatures;
207  using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
208  struct PhysicalDeviceProtectedMemoryFeatures;
209  struct PhysicalDeviceProtectedMemoryProperties;
210  struct DeviceQueueInfo2;
211  struct ProtectedSubmitInfo;
212  struct SamplerYcbcrConversionCreateInfo;
213  using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
214  struct SamplerYcbcrConversionInfo;
215  using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
216  struct BindImagePlaneMemoryInfo;
217  using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
218  struct ImagePlaneMemoryRequirementsInfo;
219  using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
220  struct PhysicalDeviceSamplerYcbcrConversionFeatures;
221  using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
222  struct SamplerYcbcrConversionImageFormatProperties;
223  using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
224  struct DescriptorUpdateTemplateEntry;
225  using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
226  struct DescriptorUpdateTemplateCreateInfo;
227  using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
228  struct ExternalMemoryProperties;
229  using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
230  struct PhysicalDeviceExternalImageFormatInfo;
231  using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
232  struct ExternalImageFormatProperties;
233  using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
234  struct PhysicalDeviceExternalBufferInfo;
235  using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
236  struct ExternalBufferProperties;
237  using ExternalBufferPropertiesKHR = ExternalBufferProperties;
238  struct PhysicalDeviceIDProperties;
239  using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
240  struct ExternalMemoryImageCreateInfo;
241  using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
242  struct ExternalMemoryBufferCreateInfo;
243  using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
244  struct ExportMemoryAllocateInfo;
245  using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
246  struct PhysicalDeviceExternalFenceInfo;
247  using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
248  struct ExternalFenceProperties;
249  using ExternalFencePropertiesKHR = ExternalFenceProperties;
250  struct ExportFenceCreateInfo;
251  using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
252  struct ExportSemaphoreCreateInfo;
253  using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
254  struct PhysicalDeviceExternalSemaphoreInfo;
255  using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
256  struct ExternalSemaphoreProperties;
257  using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
258  struct PhysicalDeviceMaintenance3Properties;
259  using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
260  struct DescriptorSetLayoutSupport;
261  using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
262  struct PhysicalDeviceShaderDrawParametersFeatures;
263  using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
264
265  //=== VK_VERSION_1_2 ===
266  struct PhysicalDeviceVulkan11Features;
267  struct PhysicalDeviceVulkan11Properties;
268  struct PhysicalDeviceVulkan12Features;
269  struct PhysicalDeviceVulkan12Properties;
270  struct ImageFormatListCreateInfo;
271  using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
272  struct RenderPassCreateInfo2;
273  using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
274  struct AttachmentDescription2;
275  using AttachmentDescription2KHR = AttachmentDescription2;
276  struct AttachmentReference2;
277  using AttachmentReference2KHR = AttachmentReference2;
278  struct SubpassDescription2;
279  using SubpassDescription2KHR = SubpassDescription2;
280  struct SubpassDependency2;
281  using SubpassDependency2KHR = SubpassDependency2;
282  struct SubpassBeginInfo;
283  using SubpassBeginInfoKHR = SubpassBeginInfo;
284  struct SubpassEndInfo;
285  using SubpassEndInfoKHR = SubpassEndInfo;
286  struct PhysicalDevice8BitStorageFeatures;
287  using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
288  struct ConformanceVersion;
289  using ConformanceVersionKHR = ConformanceVersion;
290  struct PhysicalDeviceDriverProperties;
291  using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
292  struct PhysicalDeviceShaderAtomicInt64Features;
293  using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
294  struct PhysicalDeviceShaderFloat16Int8Features;
295  using PhysicalDeviceFloat16Int8FeaturesKHR       = PhysicalDeviceShaderFloat16Int8Features;
296  using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
297  struct PhysicalDeviceFloatControlsProperties;
298  using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
299  struct DescriptorSetLayoutBindingFlagsCreateInfo;
300  using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
301  struct PhysicalDeviceDescriptorIndexingFeatures;
302  using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
303  struct PhysicalDeviceDescriptorIndexingProperties;
304  using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
305  struct DescriptorSetVariableDescriptorCountAllocateInfo;
306  using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
307  struct DescriptorSetVariableDescriptorCountLayoutSupport;
308  using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
309  struct SubpassDescriptionDepthStencilResolve;
310  using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
311  struct PhysicalDeviceDepthStencilResolveProperties;
312  using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
313  struct PhysicalDeviceScalarBlockLayoutFeatures;
314  using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
315  struct ImageStencilUsageCreateInfo;
316  using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
317  struct SamplerReductionModeCreateInfo;
318  using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
319  struct PhysicalDeviceSamplerFilterMinmaxProperties;
320  using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
321  struct PhysicalDeviceVulkanMemoryModelFeatures;
322  using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
323  struct PhysicalDeviceImagelessFramebufferFeatures;
324  using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
325  struct FramebufferAttachmentsCreateInfo;
326  using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
327  struct FramebufferAttachmentImageInfo;
328  using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
329  struct RenderPassAttachmentBeginInfo;
330  using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
331  struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
332  using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
333  struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
334  using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
335  struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
336  using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
337  struct AttachmentReferenceStencilLayout;
338  using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
339  struct AttachmentDescriptionStencilLayout;
340  using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
341  struct PhysicalDeviceHostQueryResetFeatures;
342  using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
343  struct PhysicalDeviceTimelineSemaphoreFeatures;
344  using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
345  struct PhysicalDeviceTimelineSemaphoreProperties;
346  using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
347  struct SemaphoreTypeCreateInfo;
348  using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
349  struct TimelineSemaphoreSubmitInfo;
350  using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
351  struct SemaphoreWaitInfo;
352  using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
353  struct SemaphoreSignalInfo;
354  using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
355  struct PhysicalDeviceBufferDeviceAddressFeatures;
356  using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
357  struct BufferDeviceAddressInfo;
358  using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
359  using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
360  struct BufferOpaqueCaptureAddressCreateInfo;
361  using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
362  struct MemoryOpaqueCaptureAddressAllocateInfo;
363  using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
364  struct DeviceMemoryOpaqueCaptureAddressInfo;
365  using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
366
367  //=== VK_VERSION_1_3 ===
368  struct PhysicalDeviceVulkan13Features;
369  struct PhysicalDeviceVulkan13Properties;
370  struct PipelineCreationFeedbackCreateInfo;
371  using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;
372  struct PipelineCreationFeedback;
373  using PipelineCreationFeedbackEXT = PipelineCreationFeedback;
374  struct PhysicalDeviceShaderTerminateInvocationFeatures;
375  using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;
376  struct PhysicalDeviceToolProperties;
377  using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;
378  struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
379  using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
380  struct PhysicalDevicePrivateDataFeatures;
381  using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;
382  struct DevicePrivateDataCreateInfo;
383  using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;
384  struct PrivateDataSlotCreateInfo;
385  using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;
386  struct PhysicalDevicePipelineCreationCacheControlFeatures;
387  using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;
388  struct MemoryBarrier2;
389  using MemoryBarrier2KHR = MemoryBarrier2;
390  struct BufferMemoryBarrier2;
391  using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;
392  struct ImageMemoryBarrier2;
393  using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;
394  struct DependencyInfo;
395  using DependencyInfoKHR = DependencyInfo;
396  struct SubmitInfo2;
397  using SubmitInfo2KHR = SubmitInfo2;
398  struct SemaphoreSubmitInfo;
399  using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;
400  struct CommandBufferSubmitInfo;
401  using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;
402  struct PhysicalDeviceSynchronization2Features;
403  using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;
404  struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
405  using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
406  struct PhysicalDeviceImageRobustnessFeatures;
407  using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
408  struct CopyBufferInfo2;
409  using CopyBufferInfo2KHR = CopyBufferInfo2;
410  struct CopyImageInfo2;
411  using CopyImageInfo2KHR = CopyImageInfo2;
412  struct CopyBufferToImageInfo2;
413  using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;
414  struct CopyImageToBufferInfo2;
415  using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;
416  struct BlitImageInfo2;
417  using BlitImageInfo2KHR = BlitImageInfo2;
418  struct ResolveImageInfo2;
419  using ResolveImageInfo2KHR = ResolveImageInfo2;
420  struct BufferCopy2;
421  using BufferCopy2KHR = BufferCopy2;
422  struct ImageCopy2;
423  using ImageCopy2KHR = ImageCopy2;
424  struct ImageBlit2;
425  using ImageBlit2KHR = ImageBlit2;
426  struct BufferImageCopy2;
427  using BufferImageCopy2KHR = BufferImageCopy2;
428  struct ImageResolve2;
429  using ImageResolve2KHR = ImageResolve2;
430  struct PhysicalDeviceSubgroupSizeControlFeatures;
431  using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;
432  struct PhysicalDeviceSubgroupSizeControlProperties;
433  using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;
434  struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;
435  using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
436  using ShaderRequiredSubgroupSizeCreateInfoEXT              = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
437  struct PhysicalDeviceInlineUniformBlockFeatures;
438  using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;
439  struct PhysicalDeviceInlineUniformBlockProperties;
440  using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;
441  struct WriteDescriptorSetInlineUniformBlock;
442  using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;
443  struct DescriptorPoolInlineUniformBlockCreateInfo;
444  using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;
445  struct PhysicalDeviceTextureCompressionASTCHDRFeatures;
446  using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;
447  struct RenderingInfo;
448  using RenderingInfoKHR = RenderingInfo;
449  struct RenderingAttachmentInfo;
450  using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
451  struct PipelineRenderingCreateInfo;
452  using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;
453  struct PhysicalDeviceDynamicRenderingFeatures;
454  using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
455  struct CommandBufferInheritanceRenderingInfo;
456  using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;
457  struct PhysicalDeviceShaderIntegerDotProductFeatures;
458  using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;
459  struct PhysicalDeviceShaderIntegerDotProductProperties;
460  using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;
461  struct PhysicalDeviceTexelBufferAlignmentProperties;
462  using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;
463  struct FormatProperties3;
464  using FormatProperties3KHR = FormatProperties3;
465  struct PhysicalDeviceMaintenance4Features;
466  using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;
467  struct PhysicalDeviceMaintenance4Properties;
468  using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;
469  struct DeviceBufferMemoryRequirements;
470  using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;
471  struct DeviceImageMemoryRequirements;
472  using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;
473
474  //=== VK_KHR_surface ===
475  struct SurfaceCapabilitiesKHR;
476  struct SurfaceFormatKHR;
477
478  //=== VK_KHR_swapchain ===
479  struct SwapchainCreateInfoKHR;
480  struct PresentInfoKHR;
481  struct ImageSwapchainCreateInfoKHR;
482  struct BindImageMemorySwapchainInfoKHR;
483  struct AcquireNextImageInfoKHR;
484  struct DeviceGroupPresentCapabilitiesKHR;
485  struct DeviceGroupPresentInfoKHR;
486  struct DeviceGroupSwapchainCreateInfoKHR;
487
488  //=== VK_KHR_display ===
489  struct DisplayModeCreateInfoKHR;
490  struct DisplayModeParametersKHR;
491  struct DisplayModePropertiesKHR;
492  struct DisplayPlaneCapabilitiesKHR;
493  struct DisplayPlanePropertiesKHR;
494  struct DisplayPropertiesKHR;
495  struct DisplaySurfaceCreateInfoKHR;
496
497  //=== VK_KHR_display_swapchain ===
498  struct DisplayPresentInfoKHR;
499
500#if defined( VK_USE_PLATFORM_XLIB_KHR )
501  //=== VK_KHR_xlib_surface ===
502  struct XlibSurfaceCreateInfoKHR;
503#endif /*VK_USE_PLATFORM_XLIB_KHR*/
504
505#if defined( VK_USE_PLATFORM_XCB_KHR )
506  //=== VK_KHR_xcb_surface ===
507  struct XcbSurfaceCreateInfoKHR;
508#endif /*VK_USE_PLATFORM_XCB_KHR*/
509
510#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
511  //=== VK_KHR_wayland_surface ===
512  struct WaylandSurfaceCreateInfoKHR;
513#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
514
515#if defined( VK_USE_PLATFORM_ANDROID_KHR )
516  //=== VK_KHR_android_surface ===
517  struct AndroidSurfaceCreateInfoKHR;
518#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
519
520#if defined( VK_USE_PLATFORM_WIN32_KHR )
521  //=== VK_KHR_win32_surface ===
522  struct Win32SurfaceCreateInfoKHR;
523#endif /*VK_USE_PLATFORM_WIN32_KHR*/
524
525#if defined( VK_USE_PLATFORM_OHOS )
526  //=== VK_OHOS_surface ===
527  struct SurfaceCreateInfoOHOS;
528#endif /*VK_USE_PLATFORM_OHOS*/
529
530  //=== VK_EXT_debug_report ===
531  struct DebugReportCallbackCreateInfoEXT;
532
533  //=== VK_AMD_rasterization_order ===
534  struct PipelineRasterizationStateRasterizationOrderAMD;
535
536  //=== VK_EXT_debug_marker ===
537  struct DebugMarkerObjectNameInfoEXT;
538  struct DebugMarkerObjectTagInfoEXT;
539  struct DebugMarkerMarkerInfoEXT;
540
541  //=== VK_KHR_video_queue ===
542  struct QueueFamilyQueryResultStatusPropertiesKHR;
543  struct QueueFamilyVideoPropertiesKHR;
544  struct VideoProfileInfoKHR;
545  struct VideoProfileListInfoKHR;
546  struct VideoCapabilitiesKHR;
547  struct PhysicalDeviceVideoFormatInfoKHR;
548  struct VideoFormatPropertiesKHR;
549  struct VideoPictureResourceInfoKHR;
550  struct VideoReferenceSlotInfoKHR;
551  struct VideoSessionMemoryRequirementsKHR;
552  struct BindVideoSessionMemoryInfoKHR;
553  struct VideoSessionCreateInfoKHR;
554  struct VideoSessionParametersCreateInfoKHR;
555  struct VideoSessionParametersUpdateInfoKHR;
556  struct VideoBeginCodingInfoKHR;
557  struct VideoEndCodingInfoKHR;
558  struct VideoCodingControlInfoKHR;
559
560  //=== VK_KHR_video_decode_queue ===
561  struct VideoDecodeCapabilitiesKHR;
562  struct VideoDecodeUsageInfoKHR;
563  struct VideoDecodeInfoKHR;
564
565  //=== VK_NV_dedicated_allocation ===
566  struct DedicatedAllocationImageCreateInfoNV;
567  struct DedicatedAllocationBufferCreateInfoNV;
568  struct DedicatedAllocationMemoryAllocateInfoNV;
569
570  //=== VK_EXT_transform_feedback ===
571  struct PhysicalDeviceTransformFeedbackFeaturesEXT;
572  struct PhysicalDeviceTransformFeedbackPropertiesEXT;
573  struct PipelineRasterizationStateStreamCreateInfoEXT;
574
575  //=== VK_NVX_binary_import ===
576  struct CuModuleCreateInfoNVX;
577  struct CuFunctionCreateInfoNVX;
578  struct CuLaunchInfoNVX;
579
580  //=== VK_NVX_image_view_handle ===
581  struct ImageViewHandleInfoNVX;
582  struct ImageViewAddressPropertiesNVX;
583
584  //=== VK_KHR_video_encode_h264 ===
585  struct VideoEncodeH264CapabilitiesKHR;
586  struct VideoEncodeH264QualityLevelPropertiesKHR;
587  struct VideoEncodeH264SessionCreateInfoKHR;
588  struct VideoEncodeH264SessionParametersCreateInfoKHR;
589  struct VideoEncodeH264SessionParametersAddInfoKHR;
590  struct VideoEncodeH264SessionParametersGetInfoKHR;
591  struct VideoEncodeH264SessionParametersFeedbackInfoKHR;
592  struct VideoEncodeH264PictureInfoKHR;
593  struct VideoEncodeH264DpbSlotInfoKHR;
594  struct VideoEncodeH264NaluSliceInfoKHR;
595  struct VideoEncodeH264ProfileInfoKHR;
596  struct VideoEncodeH264RateControlInfoKHR;
597  struct VideoEncodeH264RateControlLayerInfoKHR;
598  struct VideoEncodeH264QpKHR;
599  struct VideoEncodeH264FrameSizeKHR;
600  struct VideoEncodeH264GopRemainingFrameInfoKHR;
601
602  //=== VK_KHR_video_encode_h265 ===
603  struct VideoEncodeH265CapabilitiesKHR;
604  struct VideoEncodeH265SessionCreateInfoKHR;
605  struct VideoEncodeH265QualityLevelPropertiesKHR;
606  struct VideoEncodeH265SessionParametersCreateInfoKHR;
607  struct VideoEncodeH265SessionParametersAddInfoKHR;
608  struct VideoEncodeH265SessionParametersGetInfoKHR;
609  struct VideoEncodeH265SessionParametersFeedbackInfoKHR;
610  struct VideoEncodeH265PictureInfoKHR;
611  struct VideoEncodeH265DpbSlotInfoKHR;
612  struct VideoEncodeH265NaluSliceSegmentInfoKHR;
613  struct VideoEncodeH265ProfileInfoKHR;
614  struct VideoEncodeH265RateControlInfoKHR;
615  struct VideoEncodeH265RateControlLayerInfoKHR;
616  struct VideoEncodeH265QpKHR;
617  struct VideoEncodeH265FrameSizeKHR;
618  struct VideoEncodeH265GopRemainingFrameInfoKHR;
619
620  //=== VK_KHR_video_decode_h264 ===
621  struct VideoDecodeH264ProfileInfoKHR;
622  struct VideoDecodeH264CapabilitiesKHR;
623  struct VideoDecodeH264SessionParametersCreateInfoKHR;
624  struct VideoDecodeH264SessionParametersAddInfoKHR;
625  struct VideoDecodeH264PictureInfoKHR;
626  struct VideoDecodeH264DpbSlotInfoKHR;
627
628  //=== VK_AMD_texture_gather_bias_lod ===
629  struct TextureLODGatherFormatPropertiesAMD;
630
631  //=== VK_AMD_shader_info ===
632  struct ShaderResourceUsageAMD;
633  struct ShaderStatisticsInfoAMD;
634
635  //=== VK_KHR_dynamic_rendering ===
636  struct RenderingFragmentShadingRateAttachmentInfoKHR;
637  struct RenderingFragmentDensityMapAttachmentInfoEXT;
638  struct AttachmentSampleCountInfoAMD;
639  using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
640  struct MultiviewPerViewAttributesInfoNVX;
641
642#if defined( VK_USE_PLATFORM_GGP )
643  //=== VK_GGP_stream_descriptor_surface ===
644  struct StreamDescriptorSurfaceCreateInfoGGP;
645#endif /*VK_USE_PLATFORM_GGP*/
646
647  //=== VK_NV_corner_sampled_image ===
648  struct PhysicalDeviceCornerSampledImageFeaturesNV;
649
650  //=== VK_NV_external_memory_capabilities ===
651  struct ExternalImageFormatPropertiesNV;
652
653  //=== VK_NV_external_memory ===
654  struct ExternalMemoryImageCreateInfoNV;
655  struct ExportMemoryAllocateInfoNV;
656
657#if defined( VK_USE_PLATFORM_WIN32_KHR )
658  //=== VK_NV_external_memory_win32 ===
659  struct ImportMemoryWin32HandleInfoNV;
660  struct ExportMemoryWin32HandleInfoNV;
661#endif /*VK_USE_PLATFORM_WIN32_KHR*/
662
663#if defined( VK_USE_PLATFORM_WIN32_KHR )
664  //=== VK_NV_win32_keyed_mutex ===
665  struct Win32KeyedMutexAcquireReleaseInfoNV;
666#endif /*VK_USE_PLATFORM_WIN32_KHR*/
667
668  //=== VK_EXT_validation_flags ===
669  struct ValidationFlagsEXT;
670
671#if defined( VK_USE_PLATFORM_VI_NN )
672  //=== VK_NN_vi_surface ===
673  struct ViSurfaceCreateInfoNN;
674#endif /*VK_USE_PLATFORM_VI_NN*/
675
676  //=== VK_EXT_astc_decode_mode ===
677  struct ImageViewASTCDecodeModeEXT;
678  struct PhysicalDeviceASTCDecodeFeaturesEXT;
679
680  //=== VK_EXT_pipeline_robustness ===
681  struct PhysicalDevicePipelineRobustnessFeaturesEXT;
682  struct PhysicalDevicePipelineRobustnessPropertiesEXT;
683  struct PipelineRobustnessCreateInfoEXT;
684
685#if defined( VK_USE_PLATFORM_WIN32_KHR )
686  //=== VK_KHR_external_memory_win32 ===
687  struct ImportMemoryWin32HandleInfoKHR;
688  struct ExportMemoryWin32HandleInfoKHR;
689  struct MemoryWin32HandlePropertiesKHR;
690  struct MemoryGetWin32HandleInfoKHR;
691#endif /*VK_USE_PLATFORM_WIN32_KHR*/
692
693  //=== VK_KHR_external_memory_fd ===
694  struct ImportMemoryFdInfoKHR;
695  struct MemoryFdPropertiesKHR;
696  struct MemoryGetFdInfoKHR;
697
698#if defined( VK_USE_PLATFORM_WIN32_KHR )
699  //=== VK_KHR_win32_keyed_mutex ===
700  struct Win32KeyedMutexAcquireReleaseInfoKHR;
701#endif /*VK_USE_PLATFORM_WIN32_KHR*/
702
703#if defined( VK_USE_PLATFORM_WIN32_KHR )
704  //=== VK_KHR_external_semaphore_win32 ===
705  struct ImportSemaphoreWin32HandleInfoKHR;
706  struct ExportSemaphoreWin32HandleInfoKHR;
707  struct D3D12FenceSubmitInfoKHR;
708  struct SemaphoreGetWin32HandleInfoKHR;
709#endif /*VK_USE_PLATFORM_WIN32_KHR*/
710
711  //=== VK_KHR_external_semaphore_fd ===
712  struct ImportSemaphoreFdInfoKHR;
713  struct SemaphoreGetFdInfoKHR;
714
715  //=== VK_KHR_push_descriptor ===
716  struct PhysicalDevicePushDescriptorPropertiesKHR;
717
718  //=== VK_EXT_conditional_rendering ===
719  struct ConditionalRenderingBeginInfoEXT;
720  struct PhysicalDeviceConditionalRenderingFeaturesEXT;
721  struct CommandBufferInheritanceConditionalRenderingInfoEXT;
722
723  //=== VK_KHR_incremental_present ===
724  struct PresentRegionsKHR;
725  struct PresentRegionKHR;
726  struct RectLayerKHR;
727
728  //=== VK_NV_clip_space_w_scaling ===
729  struct ViewportWScalingNV;
730  struct PipelineViewportWScalingStateCreateInfoNV;
731
732  //=== VK_EXT_display_surface_counter ===
733  struct SurfaceCapabilities2EXT;
734
735  //=== VK_EXT_display_control ===
736  struct DisplayPowerInfoEXT;
737  struct DeviceEventInfoEXT;
738  struct DisplayEventInfoEXT;
739  struct SwapchainCounterCreateInfoEXT;
740
741  //=== VK_GOOGLE_display_timing ===
742  struct RefreshCycleDurationGOOGLE;
743  struct PastPresentationTimingGOOGLE;
744  struct PresentTimesInfoGOOGLE;
745  struct PresentTimeGOOGLE;
746
747  //=== VK_NVX_multiview_per_view_attributes ===
748  struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
749
750  //=== VK_NV_viewport_swizzle ===
751  struct ViewportSwizzleNV;
752  struct PipelineViewportSwizzleStateCreateInfoNV;
753
754  //=== VK_EXT_discard_rectangles ===
755  struct PhysicalDeviceDiscardRectanglePropertiesEXT;
756  struct PipelineDiscardRectangleStateCreateInfoEXT;
757
758  //=== VK_EXT_conservative_rasterization ===
759  struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
760  struct PipelineRasterizationConservativeStateCreateInfoEXT;
761
762  //=== VK_EXT_depth_clip_enable ===
763  struct PhysicalDeviceDepthClipEnableFeaturesEXT;
764  struct PipelineRasterizationDepthClipStateCreateInfoEXT;
765
766  //=== VK_EXT_hdr_metadata ===
767  struct HdrMetadataEXT;
768  struct XYColorEXT;
769
770  //=== VK_IMG_relaxed_line_rasterization ===
771  struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG;
772
773  //=== VK_KHR_shared_presentable_image ===
774  struct SharedPresentSurfaceCapabilitiesKHR;
775
776#if defined( VK_USE_PLATFORM_WIN32_KHR )
777  //=== VK_KHR_external_fence_win32 ===
778  struct ImportFenceWin32HandleInfoKHR;
779  struct ExportFenceWin32HandleInfoKHR;
780  struct FenceGetWin32HandleInfoKHR;
781#endif /*VK_USE_PLATFORM_WIN32_KHR*/
782
783  //=== VK_KHR_external_fence_fd ===
784  struct ImportFenceFdInfoKHR;
785  struct FenceGetFdInfoKHR;
786
787  //=== VK_KHR_performance_query ===
788  struct PhysicalDevicePerformanceQueryFeaturesKHR;
789  struct PhysicalDevicePerformanceQueryPropertiesKHR;
790  struct PerformanceCounterKHR;
791  struct PerformanceCounterDescriptionKHR;
792  struct QueryPoolPerformanceCreateInfoKHR;
793  union PerformanceCounterResultKHR;
794  struct AcquireProfilingLockInfoKHR;
795  struct PerformanceQuerySubmitInfoKHR;
796
797  //=== VK_KHR_get_surface_capabilities2 ===
798  struct PhysicalDeviceSurfaceInfo2KHR;
799  struct SurfaceCapabilities2KHR;
800  struct SurfaceFormat2KHR;
801
802  //=== VK_KHR_get_display_properties2 ===
803  struct DisplayProperties2KHR;
804  struct DisplayPlaneProperties2KHR;
805  struct DisplayModeProperties2KHR;
806  struct DisplayPlaneInfo2KHR;
807  struct DisplayPlaneCapabilities2KHR;
808
809#if defined( VK_USE_PLATFORM_IOS_MVK )
810  //=== VK_MVK_ios_surface ===
811  struct IOSSurfaceCreateInfoMVK;
812#endif /*VK_USE_PLATFORM_IOS_MVK*/
813
814#if defined( VK_USE_PLATFORM_MACOS_MVK )
815  //=== VK_MVK_macos_surface ===
816  struct MacOSSurfaceCreateInfoMVK;
817#endif /*VK_USE_PLATFORM_MACOS_MVK*/
818
819  //=== VK_EXT_debug_utils ===
820  struct DebugUtilsLabelEXT;
821  struct DebugUtilsMessengerCallbackDataEXT;
822  struct DebugUtilsMessengerCreateInfoEXT;
823  struct DebugUtilsObjectNameInfoEXT;
824  struct DebugUtilsObjectTagInfoEXT;
825
826#if defined( VK_USE_PLATFORM_ANDROID_KHR )
827  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
828  struct AndroidHardwareBufferUsageANDROID;
829  struct AndroidHardwareBufferPropertiesANDROID;
830  struct AndroidHardwareBufferFormatPropertiesANDROID;
831  struct ImportAndroidHardwareBufferInfoANDROID;
832  struct MemoryGetAndroidHardwareBufferInfoANDROID;
833  struct ExternalFormatANDROID;
834  struct AndroidHardwareBufferFormatProperties2ANDROID;
835#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
836
837#if defined( VK_ENABLE_BETA_EXTENSIONS )
838  //=== VK_AMDX_shader_enqueue ===
839  struct PhysicalDeviceShaderEnqueueFeaturesAMDX;
840  struct PhysicalDeviceShaderEnqueuePropertiesAMDX;
841  struct ExecutionGraphPipelineScratchSizeAMDX;
842  struct ExecutionGraphPipelineCreateInfoAMDX;
843  struct DispatchGraphInfoAMDX;
844  struct DispatchGraphCountInfoAMDX;
845  struct PipelineShaderStageNodeCreateInfoAMDX;
846  union DeviceOrHostAddressConstAMDX;
847#endif /*VK_ENABLE_BETA_EXTENSIONS*/
848
849  //=== VK_EXT_sample_locations ===
850  struct SampleLocationEXT;
851  struct SampleLocationsInfoEXT;
852  struct AttachmentSampleLocationsEXT;
853  struct SubpassSampleLocationsEXT;
854  struct RenderPassSampleLocationsBeginInfoEXT;
855  struct PipelineSampleLocationsStateCreateInfoEXT;
856  struct PhysicalDeviceSampleLocationsPropertiesEXT;
857  struct MultisamplePropertiesEXT;
858
859  //=== VK_EXT_blend_operation_advanced ===
860  struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
861  struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
862  struct PipelineColorBlendAdvancedStateCreateInfoEXT;
863
864  //=== VK_NV_fragment_coverage_to_color ===
865  struct PipelineCoverageToColorStateCreateInfoNV;
866
867  //=== VK_KHR_acceleration_structure ===
868  union DeviceOrHostAddressKHR;
869  union DeviceOrHostAddressConstKHR;
870  struct AccelerationStructureBuildRangeInfoKHR;
871  struct AabbPositionsKHR;
872  using AabbPositionsNV = AabbPositionsKHR;
873  struct AccelerationStructureGeometryTrianglesDataKHR;
874  struct TransformMatrixKHR;
875  using TransformMatrixNV = TransformMatrixKHR;
876  struct AccelerationStructureBuildGeometryInfoKHR;
877  struct AccelerationStructureGeometryAabbsDataKHR;
878  struct AccelerationStructureInstanceKHR;
879  using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
880  struct AccelerationStructureGeometryInstancesDataKHR;
881  union AccelerationStructureGeometryDataKHR;
882  struct AccelerationStructureGeometryKHR;
883  struct AccelerationStructureCreateInfoKHR;
884  struct WriteDescriptorSetAccelerationStructureKHR;
885  struct PhysicalDeviceAccelerationStructureFeaturesKHR;
886  struct PhysicalDeviceAccelerationStructurePropertiesKHR;
887  struct AccelerationStructureDeviceAddressInfoKHR;
888  struct AccelerationStructureVersionInfoKHR;
889  struct CopyAccelerationStructureToMemoryInfoKHR;
890  struct CopyMemoryToAccelerationStructureInfoKHR;
891  struct CopyAccelerationStructureInfoKHR;
892  struct AccelerationStructureBuildSizesInfoKHR;
893
894  //=== VK_KHR_ray_tracing_pipeline ===
895  struct RayTracingShaderGroupCreateInfoKHR;
896  struct RayTracingPipelineCreateInfoKHR;
897  struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
898  struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
899  struct StridedDeviceAddressRegionKHR;
900  struct TraceRaysIndirectCommandKHR;
901  struct RayTracingPipelineInterfaceCreateInfoKHR;
902
903  //=== VK_KHR_ray_query ===
904  struct PhysicalDeviceRayQueryFeaturesKHR;
905
906  //=== VK_NV_framebuffer_mixed_samples ===
907  struct PipelineCoverageModulationStateCreateInfoNV;
908
909  //=== VK_NV_shader_sm_builtins ===
910  struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
911  struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
912
913  //=== VK_EXT_image_drm_format_modifier ===
914  struct DrmFormatModifierPropertiesListEXT;
915  struct DrmFormatModifierPropertiesEXT;
916  struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
917  struct ImageDrmFormatModifierListCreateInfoEXT;
918  struct ImageDrmFormatModifierExplicitCreateInfoEXT;
919  struct ImageDrmFormatModifierPropertiesEXT;
920  struct DrmFormatModifierPropertiesList2EXT;
921  struct DrmFormatModifierProperties2EXT;
922
923  //=== VK_EXT_validation_cache ===
924  struct ValidationCacheCreateInfoEXT;
925  struct ShaderModuleValidationCacheCreateInfoEXT;
926
927#if defined( VK_ENABLE_BETA_EXTENSIONS )
928  //=== VK_KHR_portability_subset ===
929  struct PhysicalDevicePortabilitySubsetFeaturesKHR;
930  struct PhysicalDevicePortabilitySubsetPropertiesKHR;
931#endif /*VK_ENABLE_BETA_EXTENSIONS*/
932
933  //=== VK_NV_shading_rate_image ===
934  struct ShadingRatePaletteNV;
935  struct PipelineViewportShadingRateImageStateCreateInfoNV;
936  struct PhysicalDeviceShadingRateImageFeaturesNV;
937  struct PhysicalDeviceShadingRateImagePropertiesNV;
938  struct CoarseSampleLocationNV;
939  struct CoarseSampleOrderCustomNV;
940  struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
941
942  //=== VK_NV_ray_tracing ===
943  struct RayTracingShaderGroupCreateInfoNV;
944  struct RayTracingPipelineCreateInfoNV;
945  struct GeometryTrianglesNV;
946  struct GeometryAABBNV;
947  struct GeometryDataNV;
948  struct GeometryNV;
949  struct AccelerationStructureInfoNV;
950  struct AccelerationStructureCreateInfoNV;
951  struct BindAccelerationStructureMemoryInfoNV;
952  struct WriteDescriptorSetAccelerationStructureNV;
953  struct AccelerationStructureMemoryRequirementsInfoNV;
954  struct PhysicalDeviceRayTracingPropertiesNV;
955
956  //=== VK_NV_representative_fragment_test ===
957  struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
958  struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
959
960  //=== VK_EXT_filter_cubic ===
961  struct PhysicalDeviceImageViewImageFormatInfoEXT;
962  struct FilterCubicImageViewImageFormatPropertiesEXT;
963
964  //=== VK_EXT_external_memory_host ===
965  struct ImportMemoryHostPointerInfoEXT;
966  struct MemoryHostPointerPropertiesEXT;
967  struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
968
969  //=== VK_KHR_shader_clock ===
970  struct PhysicalDeviceShaderClockFeaturesKHR;
971
972  //=== VK_AMD_pipeline_compiler_control ===
973  struct PipelineCompilerControlCreateInfoAMD;
974
975  //=== VK_AMD_shader_core_properties ===
976  struct PhysicalDeviceShaderCorePropertiesAMD;
977
978  //=== VK_KHR_video_decode_h265 ===
979  struct VideoDecodeH265ProfileInfoKHR;
980  struct VideoDecodeH265CapabilitiesKHR;
981  struct VideoDecodeH265SessionParametersCreateInfoKHR;
982  struct VideoDecodeH265SessionParametersAddInfoKHR;
983  struct VideoDecodeH265PictureInfoKHR;
984  struct VideoDecodeH265DpbSlotInfoKHR;
985
986  //=== VK_KHR_global_priority ===
987  struct DeviceQueueGlobalPriorityCreateInfoKHR;
988  using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR;
989  struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
990  using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
991  struct QueueFamilyGlobalPriorityPropertiesKHR;
992  using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR;
993
994  //=== VK_AMD_memory_overallocation_behavior ===
995  struct DeviceMemoryOverallocationCreateInfoAMD;
996
997  //=== VK_EXT_vertex_attribute_divisor ===
998  struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
999
1000#if defined( VK_USE_PLATFORM_GGP )
1001  //=== VK_GGP_frame_token ===
1002  struct PresentFrameTokenGGP;
1003#endif /*VK_USE_PLATFORM_GGP*/
1004
1005  //=== VK_NV_compute_shader_derivatives ===
1006  struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
1007
1008  //=== VK_NV_mesh_shader ===
1009  struct PhysicalDeviceMeshShaderFeaturesNV;
1010  struct PhysicalDeviceMeshShaderPropertiesNV;
1011  struct DrawMeshTasksIndirectCommandNV;
1012
1013  //=== VK_NV_shader_image_footprint ===
1014  struct PhysicalDeviceShaderImageFootprintFeaturesNV;
1015
1016  //=== VK_NV_scissor_exclusive ===
1017  struct PipelineViewportExclusiveScissorStateCreateInfoNV;
1018  struct PhysicalDeviceExclusiveScissorFeaturesNV;
1019
1020  //=== VK_NV_device_diagnostic_checkpoints ===
1021  struct QueueFamilyCheckpointPropertiesNV;
1022  struct CheckpointDataNV;
1023
1024  //=== VK_INTEL_shader_integer_functions2 ===
1025  struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
1026
1027  //=== VK_INTEL_performance_query ===
1028  union PerformanceValueDataINTEL;
1029  struct PerformanceValueINTEL;
1030  struct InitializePerformanceApiInfoINTEL;
1031  struct QueryPoolPerformanceQueryCreateInfoINTEL;
1032  using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
1033  struct PerformanceMarkerInfoINTEL;
1034  struct PerformanceStreamMarkerInfoINTEL;
1035  struct PerformanceOverrideInfoINTEL;
1036  struct PerformanceConfigurationAcquireInfoINTEL;
1037
1038  //=== VK_EXT_pci_bus_info ===
1039  struct PhysicalDevicePCIBusInfoPropertiesEXT;
1040
1041  //=== VK_AMD_display_native_hdr ===
1042  struct DisplayNativeHdrSurfaceCapabilitiesAMD;
1043  struct SwapchainDisplayNativeHdrCreateInfoAMD;
1044
1045#if defined( VK_USE_PLATFORM_FUCHSIA )
1046  //=== VK_FUCHSIA_imagepipe_surface ===
1047  struct ImagePipeSurfaceCreateInfoFUCHSIA;
1048#endif /*VK_USE_PLATFORM_FUCHSIA*/
1049
1050#if defined( VK_USE_PLATFORM_METAL_EXT )
1051  //=== VK_EXT_metal_surface ===
1052  struct MetalSurfaceCreateInfoEXT;
1053#endif /*VK_USE_PLATFORM_METAL_EXT*/
1054
1055  //=== VK_EXT_fragment_density_map ===
1056  struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
1057  struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
1058  struct RenderPassFragmentDensityMapCreateInfoEXT;
1059
1060  //=== VK_KHR_fragment_shading_rate ===
1061  struct FragmentShadingRateAttachmentInfoKHR;
1062  struct PipelineFragmentShadingRateStateCreateInfoKHR;
1063  struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
1064  struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
1065  struct PhysicalDeviceFragmentShadingRateKHR;
1066
1067  //=== VK_AMD_shader_core_properties2 ===
1068  struct PhysicalDeviceShaderCoreProperties2AMD;
1069
1070  //=== VK_AMD_device_coherent_memory ===
1071  struct PhysicalDeviceCoherentMemoryFeaturesAMD;
1072
1073  //=== VK_EXT_shader_image_atomic_int64 ===
1074  struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
1075
1076  //=== VK_EXT_memory_budget ===
1077  struct PhysicalDeviceMemoryBudgetPropertiesEXT;
1078
1079  //=== VK_EXT_memory_priority ===
1080  struct PhysicalDeviceMemoryPriorityFeaturesEXT;
1081  struct MemoryPriorityAllocateInfoEXT;
1082
1083  //=== VK_KHR_surface_protected_capabilities ===
1084  struct SurfaceProtectedCapabilitiesKHR;
1085
1086  //=== VK_NV_dedicated_allocation_image_aliasing ===
1087  struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
1088
1089  //=== VK_EXT_buffer_device_address ===
1090  struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1091  using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1092  struct BufferDeviceAddressCreateInfoEXT;
1093
1094  //=== VK_EXT_validation_features ===
1095  struct ValidationFeaturesEXT;
1096
1097  //=== VK_KHR_present_wait ===
1098  struct PhysicalDevicePresentWaitFeaturesKHR;
1099
1100  //=== VK_NV_cooperative_matrix ===
1101  struct CooperativeMatrixPropertiesNV;
1102  struct PhysicalDeviceCooperativeMatrixFeaturesNV;
1103  struct PhysicalDeviceCooperativeMatrixPropertiesNV;
1104
1105  //=== VK_NV_coverage_reduction_mode ===
1106  struct PhysicalDeviceCoverageReductionModeFeaturesNV;
1107  struct PipelineCoverageReductionStateCreateInfoNV;
1108  struct FramebufferMixedSamplesCombinationNV;
1109
1110  //=== VK_EXT_fragment_shader_interlock ===
1111  struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
1112
1113  //=== VK_EXT_ycbcr_image_arrays ===
1114  struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
1115
1116  //=== VK_EXT_provoking_vertex ===
1117  struct PhysicalDeviceProvokingVertexFeaturesEXT;
1118  struct PhysicalDeviceProvokingVertexPropertiesEXT;
1119  struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
1120
1121#if defined( VK_USE_PLATFORM_WIN32_KHR )
1122  //=== VK_EXT_full_screen_exclusive ===
1123  struct SurfaceFullScreenExclusiveInfoEXT;
1124  struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1125  struct SurfaceFullScreenExclusiveWin32InfoEXT;
1126#endif /*VK_USE_PLATFORM_WIN32_KHR*/
1127
1128  //=== VK_EXT_headless_surface ===
1129  struct HeadlessSurfaceCreateInfoEXT;
1130
1131  //=== VK_EXT_line_rasterization ===
1132  struct PhysicalDeviceLineRasterizationFeaturesEXT;
1133  struct PhysicalDeviceLineRasterizationPropertiesEXT;
1134  struct PipelineRasterizationLineStateCreateInfoEXT;
1135
1136  //=== VK_EXT_shader_atomic_float ===
1137  struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
1138
1139  //=== VK_EXT_index_type_uint8 ===
1140  struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
1141
1142  //=== VK_EXT_extended_dynamic_state ===
1143  struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
1144
1145  //=== VK_KHR_pipeline_executable_properties ===
1146  struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
1147  struct PipelineInfoKHR;
1148  using PipelineInfoEXT = PipelineInfoKHR;
1149  struct PipelineExecutablePropertiesKHR;
1150  struct PipelineExecutableInfoKHR;
1151  union PipelineExecutableStatisticValueKHR;
1152  struct PipelineExecutableStatisticKHR;
1153  struct PipelineExecutableInternalRepresentationKHR;
1154
1155  //=== VK_EXT_host_image_copy ===
1156  struct PhysicalDeviceHostImageCopyFeaturesEXT;
1157  struct PhysicalDeviceHostImageCopyPropertiesEXT;
1158  struct MemoryToImageCopyEXT;
1159  struct ImageToMemoryCopyEXT;
1160  struct CopyMemoryToImageInfoEXT;
1161  struct CopyImageToMemoryInfoEXT;
1162  struct CopyImageToImageInfoEXT;
1163  struct HostImageLayoutTransitionInfoEXT;
1164  struct SubresourceHostMemcpySizeEXT;
1165  struct HostImageCopyDevicePerformanceQueryEXT;
1166
1167  //=== VK_KHR_map_memory2 ===
1168  struct MemoryMapInfoKHR;
1169  struct MemoryUnmapInfoKHR;
1170
1171  //=== VK_EXT_shader_atomic_float2 ===
1172  struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
1173
1174  //=== VK_EXT_surface_maintenance1 ===
1175  struct SurfacePresentModeEXT;
1176  struct SurfacePresentScalingCapabilitiesEXT;
1177  struct SurfacePresentModeCompatibilityEXT;
1178
1179  //=== VK_EXT_swapchain_maintenance1 ===
1180  struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT;
1181  struct SwapchainPresentFenceInfoEXT;
1182  struct SwapchainPresentModesCreateInfoEXT;
1183  struct SwapchainPresentModeInfoEXT;
1184  struct SwapchainPresentScalingCreateInfoEXT;
1185  struct ReleaseSwapchainImagesInfoEXT;
1186
1187  //=== VK_NV_device_generated_commands ===
1188  struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
1189  struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
1190  struct GraphicsShaderGroupCreateInfoNV;
1191  struct GraphicsPipelineShaderGroupsCreateInfoNV;
1192  struct BindShaderGroupIndirectCommandNV;
1193  struct BindIndexBufferIndirectCommandNV;
1194  struct BindVertexBufferIndirectCommandNV;
1195  struct SetStateFlagsIndirectCommandNV;
1196  struct IndirectCommandsStreamNV;
1197  struct IndirectCommandsLayoutTokenNV;
1198  struct IndirectCommandsLayoutCreateInfoNV;
1199  struct GeneratedCommandsInfoNV;
1200  struct GeneratedCommandsMemoryRequirementsInfoNV;
1201
1202  //=== VK_NV_inherited_viewport_scissor ===
1203  struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
1204  struct CommandBufferInheritanceViewportScissorInfoNV;
1205
1206  //=== VK_EXT_texel_buffer_alignment ===
1207  struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
1208
1209  //=== VK_QCOM_render_pass_transform ===
1210  struct RenderPassTransformBeginInfoQCOM;
1211  struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
1212
1213  //=== VK_EXT_depth_bias_control ===
1214  struct PhysicalDeviceDepthBiasControlFeaturesEXT;
1215  struct DepthBiasInfoEXT;
1216  struct DepthBiasRepresentationInfoEXT;
1217
1218  //=== VK_EXT_device_memory_report ===
1219  struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
1220  struct DeviceDeviceMemoryReportCreateInfoEXT;
1221  struct DeviceMemoryReportCallbackDataEXT;
1222
1223  //=== VK_EXT_robustness2 ===
1224  struct PhysicalDeviceRobustness2FeaturesEXT;
1225  struct PhysicalDeviceRobustness2PropertiesEXT;
1226
1227  //=== VK_EXT_custom_border_color ===
1228  struct SamplerCustomBorderColorCreateInfoEXT;
1229  struct PhysicalDeviceCustomBorderColorPropertiesEXT;
1230  struct PhysicalDeviceCustomBorderColorFeaturesEXT;
1231
1232  //=== VK_KHR_pipeline_library ===
1233  struct PipelineLibraryCreateInfoKHR;
1234
1235  //=== VK_NV_present_barrier ===
1236  struct PhysicalDevicePresentBarrierFeaturesNV;
1237  struct SurfaceCapabilitiesPresentBarrierNV;
1238  struct SwapchainPresentBarrierCreateInfoNV;
1239
1240  //=== VK_KHR_present_id ===
1241  struct PresentIdKHR;
1242  struct PhysicalDevicePresentIdFeaturesKHR;
1243
1244  //=== VK_KHR_video_encode_queue ===
1245  struct VideoEncodeInfoKHR;
1246  struct VideoEncodeCapabilitiesKHR;
1247  struct QueryPoolVideoEncodeFeedbackCreateInfoKHR;
1248  struct VideoEncodeUsageInfoKHR;
1249  struct VideoEncodeRateControlInfoKHR;
1250  struct VideoEncodeRateControlLayerInfoKHR;
1251  struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR;
1252  struct VideoEncodeQualityLevelPropertiesKHR;
1253  struct VideoEncodeQualityLevelInfoKHR;
1254  struct VideoEncodeSessionParametersGetInfoKHR;
1255  struct VideoEncodeSessionParametersFeedbackInfoKHR;
1256
1257  //=== VK_NV_device_diagnostics_config ===
1258  struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
1259  struct DeviceDiagnosticsConfigCreateInfoNV;
1260
1261#if defined( VK_ENABLE_BETA_EXTENSIONS )
1262  //=== VK_NV_cuda_kernel_launch ===
1263  struct CudaModuleCreateInfoNV;
1264  struct CudaFunctionCreateInfoNV;
1265  struct CudaLaunchInfoNV;
1266  struct PhysicalDeviceCudaKernelLaunchFeaturesNV;
1267  struct PhysicalDeviceCudaKernelLaunchPropertiesNV;
1268#endif /*VK_ENABLE_BETA_EXTENSIONS*/
1269
1270  //=== VK_NV_low_latency ===
1271  struct QueryLowLatencySupportNV;
1272
1273#if defined( VK_USE_PLATFORM_METAL_EXT )
1274  //=== VK_EXT_metal_objects ===
1275  struct ExportMetalObjectCreateInfoEXT;
1276  struct ExportMetalObjectsInfoEXT;
1277  struct ExportMetalDeviceInfoEXT;
1278  struct ExportMetalCommandQueueInfoEXT;
1279  struct ExportMetalBufferInfoEXT;
1280  struct ImportMetalBufferInfoEXT;
1281  struct ExportMetalTextureInfoEXT;
1282  struct ImportMetalTextureInfoEXT;
1283  struct ExportMetalIOSurfaceInfoEXT;
1284  struct ImportMetalIOSurfaceInfoEXT;
1285  struct ExportMetalSharedEventInfoEXT;
1286  struct ImportMetalSharedEventInfoEXT;
1287#endif /*VK_USE_PLATFORM_METAL_EXT*/
1288
1289  //=== VK_KHR_synchronization2 ===
1290  struct QueueFamilyCheckpointProperties2NV;
1291  struct CheckpointData2NV;
1292
1293  //=== VK_EXT_descriptor_buffer ===
1294  struct PhysicalDeviceDescriptorBufferPropertiesEXT;
1295  struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
1296  struct PhysicalDeviceDescriptorBufferFeaturesEXT;
1297  struct DescriptorAddressInfoEXT;
1298  struct DescriptorBufferBindingInfoEXT;
1299  struct DescriptorBufferBindingPushDescriptorBufferHandleEXT;
1300  union DescriptorDataEXT;
1301  struct DescriptorGetInfoEXT;
1302  struct BufferCaptureDescriptorDataInfoEXT;
1303  struct ImageCaptureDescriptorDataInfoEXT;
1304  struct ImageViewCaptureDescriptorDataInfoEXT;
1305  struct SamplerCaptureDescriptorDataInfoEXT;
1306  struct OpaqueCaptureDescriptorDataCreateInfoEXT;
1307  struct AccelerationStructureCaptureDescriptorDataInfoEXT;
1308
1309  //=== VK_EXT_graphics_pipeline_library ===
1310  struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
1311  struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
1312  struct GraphicsPipelineLibraryCreateInfoEXT;
1313
1314  //=== VK_AMD_shader_early_and_late_fragment_tests ===
1315  struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
1316
1317  //=== VK_KHR_fragment_shader_barycentric ===
1318  struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1319  using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1320  struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
1321
1322  //=== VK_KHR_shader_subgroup_uniform_control_flow ===
1323  struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
1324
1325  //=== VK_NV_fragment_shading_rate_enums ===
1326  struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
1327  struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
1328  struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
1329
1330  //=== VK_NV_ray_tracing_motion_blur ===
1331  struct AccelerationStructureGeometryMotionTrianglesDataNV;
1332  struct AccelerationStructureMotionInfoNV;
1333  struct AccelerationStructureMotionInstanceNV;
1334  union AccelerationStructureMotionInstanceDataNV;
1335  struct AccelerationStructureMatrixMotionInstanceNV;
1336  struct AccelerationStructureSRTMotionInstanceNV;
1337  struct SRTDataNV;
1338  struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
1339
1340  //=== VK_EXT_mesh_shader ===
1341  struct PhysicalDeviceMeshShaderFeaturesEXT;
1342  struct PhysicalDeviceMeshShaderPropertiesEXT;
1343  struct DrawMeshTasksIndirectCommandEXT;
1344
1345  //=== VK_EXT_ycbcr_2plane_444_formats ===
1346  struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
1347
1348  //=== VK_EXT_fragment_density_map2 ===
1349  struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
1350  struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
1351
1352  //=== VK_QCOM_rotated_copy_commands ===
1353  struct CopyCommandTransformInfoQCOM;
1354
1355  //=== VK_KHR_workgroup_memory_explicit_layout ===
1356  struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
1357
1358  //=== VK_EXT_image_compression_control ===
1359  struct PhysicalDeviceImageCompressionControlFeaturesEXT;
1360  struct ImageCompressionControlEXT;
1361  struct ImageCompressionPropertiesEXT;
1362
1363  //=== VK_EXT_attachment_feedback_loop_layout ===
1364  struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
1365
1366  //=== VK_EXT_4444_formats ===
1367  struct PhysicalDevice4444FormatsFeaturesEXT;
1368
1369  //=== VK_EXT_device_fault ===
1370  struct PhysicalDeviceFaultFeaturesEXT;
1371  struct DeviceFaultCountsEXT;
1372  struct DeviceFaultInfoEXT;
1373  struct DeviceFaultAddressInfoEXT;
1374  struct DeviceFaultVendorInfoEXT;
1375  struct DeviceFaultVendorBinaryHeaderVersionOneEXT;
1376
1377  //=== VK_EXT_rgba10x6_formats ===
1378  struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
1379
1380#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
1381  //=== VK_EXT_directfb_surface ===
1382  struct DirectFBSurfaceCreateInfoEXT;
1383#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
1384
1385  //=== VK_EXT_vertex_input_dynamic_state ===
1386  struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
1387  struct VertexInputBindingDescription2EXT;
1388  struct VertexInputAttributeDescription2EXT;
1389
1390  //=== VK_EXT_physical_device_drm ===
1391  struct PhysicalDeviceDrmPropertiesEXT;
1392
1393  //=== VK_EXT_device_address_binding_report ===
1394  struct PhysicalDeviceAddressBindingReportFeaturesEXT;
1395  struct DeviceAddressBindingCallbackDataEXT;
1396
1397  //=== VK_EXT_depth_clip_control ===
1398  struct PhysicalDeviceDepthClipControlFeaturesEXT;
1399  struct PipelineViewportDepthClipControlCreateInfoEXT;
1400
1401  //=== VK_EXT_primitive_topology_list_restart ===
1402  struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
1403
1404#if defined( VK_USE_PLATFORM_FUCHSIA )
1405  //=== VK_FUCHSIA_external_memory ===
1406  struct ImportMemoryZirconHandleInfoFUCHSIA;
1407  struct MemoryZirconHandlePropertiesFUCHSIA;
1408  struct MemoryGetZirconHandleInfoFUCHSIA;
1409#endif /*VK_USE_PLATFORM_FUCHSIA*/
1410
1411#if defined( VK_USE_PLATFORM_FUCHSIA )
1412  //=== VK_FUCHSIA_external_semaphore ===
1413  struct ImportSemaphoreZirconHandleInfoFUCHSIA;
1414  struct SemaphoreGetZirconHandleInfoFUCHSIA;
1415#endif /*VK_USE_PLATFORM_FUCHSIA*/
1416
1417#if defined( VK_USE_PLATFORM_FUCHSIA )
1418  //=== VK_FUCHSIA_buffer_collection ===
1419  struct BufferCollectionCreateInfoFUCHSIA;
1420  struct ImportMemoryBufferCollectionFUCHSIA;
1421  struct BufferCollectionImageCreateInfoFUCHSIA;
1422  struct BufferConstraintsInfoFUCHSIA;
1423  struct BufferCollectionBufferCreateInfoFUCHSIA;
1424  struct BufferCollectionPropertiesFUCHSIA;
1425  struct SysmemColorSpaceFUCHSIA;
1426  struct ImageConstraintsInfoFUCHSIA;
1427  struct ImageFormatConstraintsInfoFUCHSIA;
1428  struct BufferCollectionConstraintsInfoFUCHSIA;
1429#endif /*VK_USE_PLATFORM_FUCHSIA*/
1430
1431  //=== VK_HUAWEI_subpass_shading ===
1432  struct SubpassShadingPipelineCreateInfoHUAWEI;
1433  struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
1434  struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
1435
1436  //=== VK_HUAWEI_invocation_mask ===
1437  struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;
1438
1439  //=== VK_NV_external_memory_rdma ===
1440  struct MemoryGetRemoteAddressInfoNV;
1441  struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
1442
1443  //=== VK_EXT_pipeline_properties ===
1444  struct PipelinePropertiesIdentifierEXT;
1445  struct PhysicalDevicePipelinePropertiesFeaturesEXT;
1446
1447  //=== VK_EXT_frame_boundary ===
1448  struct PhysicalDeviceFrameBoundaryFeaturesEXT;
1449  struct FrameBoundaryEXT;
1450
1451  //=== VK_EXT_multisampled_render_to_single_sampled ===
1452  struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
1453  struct SubpassResolvePerformanceQueryEXT;
1454  struct MultisampledRenderToSingleSampledInfoEXT;
1455
1456  //=== VK_EXT_extended_dynamic_state2 ===
1457  struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
1458
1459#if defined( VK_USE_PLATFORM_SCREEN_QNX )
1460  //=== VK_QNX_screen_surface ===
1461  struct ScreenSurfaceCreateInfoQNX;
1462#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1463
1464  //=== VK_EXT_color_write_enable ===
1465  struct PhysicalDeviceColorWriteEnableFeaturesEXT;
1466  struct PipelineColorWriteCreateInfoEXT;
1467
1468  //=== VK_EXT_primitives_generated_query ===
1469  struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
1470
1471  //=== VK_KHR_ray_tracing_maintenance1 ===
1472  struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
1473  struct TraceRaysIndirectCommand2KHR;
1474
1475  //=== VK_EXT_image_view_min_lod ===
1476  struct PhysicalDeviceImageViewMinLodFeaturesEXT;
1477  struct ImageViewMinLodCreateInfoEXT;
1478
1479  //=== VK_EXT_multi_draw ===
1480  struct PhysicalDeviceMultiDrawFeaturesEXT;
1481  struct PhysicalDeviceMultiDrawPropertiesEXT;
1482  struct MultiDrawInfoEXT;
1483  struct MultiDrawIndexedInfoEXT;
1484
1485  //=== VK_EXT_image_2d_view_of_3d ===
1486  struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;
1487
1488  //=== VK_EXT_shader_tile_image ===
1489  struct PhysicalDeviceShaderTileImageFeaturesEXT;
1490  struct PhysicalDeviceShaderTileImagePropertiesEXT;
1491
1492  //=== VK_EXT_opacity_micromap ===
1493  struct MicromapBuildInfoEXT;
1494  struct MicromapUsageEXT;
1495  struct MicromapCreateInfoEXT;
1496  struct PhysicalDeviceOpacityMicromapFeaturesEXT;
1497  struct PhysicalDeviceOpacityMicromapPropertiesEXT;
1498  struct MicromapVersionInfoEXT;
1499  struct CopyMicromapToMemoryInfoEXT;
1500  struct CopyMemoryToMicromapInfoEXT;
1501  struct CopyMicromapInfoEXT;
1502  struct MicromapBuildSizesInfoEXT;
1503  struct AccelerationStructureTrianglesOpacityMicromapEXT;
1504  struct MicromapTriangleEXT;
1505
1506#if defined( VK_ENABLE_BETA_EXTENSIONS )
1507  //=== VK_NV_displacement_micromap ===
1508  struct PhysicalDeviceDisplacementMicromapFeaturesNV;
1509  struct PhysicalDeviceDisplacementMicromapPropertiesNV;
1510  struct AccelerationStructureTrianglesDisplacementMicromapNV;
1511#endif /*VK_ENABLE_BETA_EXTENSIONS*/
1512
1513  //=== VK_HUAWEI_cluster_culling_shader ===
1514  struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
1515  struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
1516  struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI;
1517
1518  //=== VK_EXT_border_color_swizzle ===
1519  struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;
1520  struct SamplerBorderColorComponentMappingCreateInfoEXT;
1521
1522  //=== VK_EXT_pageable_device_local_memory ===
1523  struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
1524
1525  //=== VK_ARM_shader_core_properties ===
1526  struct PhysicalDeviceShaderCorePropertiesARM;
1527
1528  //=== VK_ARM_scheduling_controls ===
1529  struct DeviceQueueShaderCoreControlCreateInfoARM;
1530  struct PhysicalDeviceSchedulingControlsFeaturesARM;
1531  struct PhysicalDeviceSchedulingControlsPropertiesARM;
1532
1533  //=== VK_EXT_image_sliced_view_of_3d ===
1534  struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
1535  struct ImageViewSlicedCreateInfoEXT;
1536
1537  //=== VK_VALVE_descriptor_set_host_mapping ===
1538  struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
1539  struct DescriptorSetBindingReferenceVALVE;
1540  struct DescriptorSetLayoutHostMappingInfoVALVE;
1541
1542  //=== VK_EXT_depth_clamp_zero_one ===
1543  struct PhysicalDeviceDepthClampZeroOneFeaturesEXT;
1544
1545  //=== VK_EXT_non_seamless_cube_map ===
1546  struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
1547
1548  //=== VK_ARM_render_pass_striped ===
1549  struct PhysicalDeviceRenderPassStripedFeaturesARM;
1550  struct PhysicalDeviceRenderPassStripedPropertiesARM;
1551  struct RenderPassStripeBeginInfoARM;
1552  struct RenderPassStripeInfoARM;
1553  struct RenderPassStripeSubmitInfoARM;
1554
1555  //=== VK_QCOM_fragment_density_map_offset ===
1556  struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
1557  struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
1558  struct SubpassFragmentDensityMapOffsetEndInfoQCOM;
1559
1560  //=== VK_NV_copy_memory_indirect ===
1561  struct CopyMemoryIndirectCommandNV;
1562  struct CopyMemoryToImageIndirectCommandNV;
1563  struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;
1564  struct PhysicalDeviceCopyMemoryIndirectPropertiesNV;
1565
1566  //=== VK_NV_memory_decompression ===
1567  struct DecompressMemoryRegionNV;
1568  struct PhysicalDeviceMemoryDecompressionFeaturesNV;
1569  struct PhysicalDeviceMemoryDecompressionPropertiesNV;
1570
1571  //=== VK_NV_device_generated_commands_compute ===
1572  struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
1573  struct ComputePipelineIndirectBufferInfoNV;
1574  struct PipelineIndirectDeviceAddressInfoNV;
1575  struct BindPipelineIndirectCommandNV;
1576
1577  //=== VK_NV_linear_color_attachment ===
1578  struct PhysicalDeviceLinearColorAttachmentFeaturesNV;
1579
1580  //=== VK_EXT_image_compression_control_swapchain ===
1581  struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
1582
1583  //=== VK_QCOM_image_processing ===
1584  struct ImageViewSampleWeightCreateInfoQCOM;
1585  struct PhysicalDeviceImageProcessingFeaturesQCOM;
1586  struct PhysicalDeviceImageProcessingPropertiesQCOM;
1587
1588  //=== VK_EXT_nested_command_buffer ===
1589  struct PhysicalDeviceNestedCommandBufferFeaturesEXT;
1590  struct PhysicalDeviceNestedCommandBufferPropertiesEXT;
1591
1592  //=== VK_EXT_external_memory_acquire_unmodified ===
1593  struct ExternalMemoryAcquireUnmodifiedEXT;
1594
1595  //=== VK_EXT_extended_dynamic_state3 ===
1596  struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;
1597  struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;
1598  struct ColorBlendEquationEXT;
1599  struct ColorBlendAdvancedEXT;
1600
1601  //=== VK_EXT_subpass_merge_feedback ===
1602  struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
1603  struct RenderPassCreationControlEXT;
1604  struct RenderPassCreationFeedbackInfoEXT;
1605  struct RenderPassCreationFeedbackCreateInfoEXT;
1606  struct RenderPassSubpassFeedbackInfoEXT;
1607  struct RenderPassSubpassFeedbackCreateInfoEXT;
1608
1609  //=== VK_LUNARG_direct_driver_loading ===
1610  struct DirectDriverLoadingInfoLUNARG;
1611  struct DirectDriverLoadingListLUNARG;
1612
1613  //=== VK_EXT_shader_module_identifier ===
1614  struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
1615  struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
1616  struct PipelineShaderStageModuleIdentifierCreateInfoEXT;
1617  struct ShaderModuleIdentifierEXT;
1618
1619  //=== VK_EXT_rasterization_order_attachment_access ===
1620  struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1621  using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1622
1623  //=== VK_NV_optical_flow ===
1624  struct PhysicalDeviceOpticalFlowFeaturesNV;
1625  struct PhysicalDeviceOpticalFlowPropertiesNV;
1626  struct OpticalFlowImageFormatInfoNV;
1627  struct OpticalFlowImageFormatPropertiesNV;
1628  struct OpticalFlowSessionCreateInfoNV;
1629  struct OpticalFlowSessionCreatePrivateDataInfoNV;
1630  struct OpticalFlowExecuteInfoNV;
1631
1632  //=== VK_EXT_legacy_dithering ===
1633  struct PhysicalDeviceLegacyDitheringFeaturesEXT;
1634
1635  //=== VK_EXT_pipeline_protected_access ===
1636  struct PhysicalDevicePipelineProtectedAccessFeaturesEXT;
1637
1638#if defined( VK_USE_PLATFORM_ANDROID_KHR )
1639  //=== VK_ANDROID_external_format_resolve ===
1640  struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;
1641  struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;
1642  struct AndroidHardwareBufferFormatResolvePropertiesANDROID;
1643#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1644
1645  //=== VK_KHR_maintenance5 ===
1646  struct PhysicalDeviceMaintenance5FeaturesKHR;
1647  struct PhysicalDeviceMaintenance5PropertiesKHR;
1648  struct RenderingAreaInfoKHR;
1649  struct DeviceImageSubresourceInfoKHR;
1650  struct ImageSubresource2KHR;
1651  using ImageSubresource2EXT = ImageSubresource2KHR;
1652  struct SubresourceLayout2KHR;
1653  using SubresourceLayout2EXT = SubresourceLayout2KHR;
1654  struct PipelineCreateFlags2CreateInfoKHR;
1655  struct BufferUsageFlags2CreateInfoKHR;
1656
1657  //=== VK_KHR_ray_tracing_position_fetch ===
1658  struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
1659
1660  //=== VK_EXT_shader_object ===
1661  struct PhysicalDeviceShaderObjectFeaturesEXT;
1662  struct PhysicalDeviceShaderObjectPropertiesEXT;
1663  struct ShaderCreateInfoEXT;
1664
1665  //=== VK_QCOM_tile_properties ===
1666  struct PhysicalDeviceTilePropertiesFeaturesQCOM;
1667  struct TilePropertiesQCOM;
1668
1669  //=== VK_SEC_amigo_profiling ===
1670  struct PhysicalDeviceAmigoProfilingFeaturesSEC;
1671  struct AmigoProfilingSubmitInfoSEC;
1672
1673  //=== VK_QCOM_multiview_per_view_viewports ===
1674  struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
1675
1676  //=== VK_NV_ray_tracing_invocation_reorder ===
1677  struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
1678  struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
1679
1680  //=== VK_NV_extended_sparse_address_space ===
1681  struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
1682  struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
1683
1684  //=== VK_EXT_mutable_descriptor_type ===
1685  struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1686  using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1687  struct MutableDescriptorTypeListEXT;
1688  using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;
1689  struct MutableDescriptorTypeCreateInfoEXT;
1690  using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
1691
1692  //=== VK_EXT_layer_settings ===
1693  struct LayerSettingsCreateInfoEXT;
1694  struct LayerSettingEXT;
1695
1696  //=== VK_ARM_shader_core_builtins ===
1697  struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
1698  struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
1699
1700  //=== VK_EXT_pipeline_library_group_handles ===
1701  struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
1702
1703  //=== VK_EXT_dynamic_rendering_unused_attachments ===
1704  struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
1705
1706  //=== VK_NV_low_latency2 ===
1707  struct LatencySleepModeInfoNV;
1708  struct LatencySleepInfoNV;
1709  struct SetLatencyMarkerInfoNV;
1710  struct GetLatencyMarkerInfoNV;
1711  struct LatencyTimingsFrameReportNV;
1712  struct LatencySubmissionPresentIdNV;
1713  struct SwapchainLatencyCreateInfoNV;
1714  struct OutOfBandQueueTypeInfoNV;
1715  struct LatencySurfaceCapabilitiesNV;
1716
1717  //=== VK_KHR_cooperative_matrix ===
1718  struct CooperativeMatrixPropertiesKHR;
1719  struct PhysicalDeviceCooperativeMatrixFeaturesKHR;
1720  struct PhysicalDeviceCooperativeMatrixPropertiesKHR;
1721
1722  //=== VK_QCOM_multiview_per_view_render_areas ===
1723  struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
1724  struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
1725
1726  //=== VK_KHR_video_maintenance1 ===
1727  struct PhysicalDeviceVideoMaintenance1FeaturesKHR;
1728  struct VideoInlineQueryInfoKHR;
1729
1730  //=== VK_NV_per_stage_descriptor_set ===
1731  struct PhysicalDevicePerStageDescriptorSetFeaturesNV;
1732
1733  //=== VK_QCOM_image_processing2 ===
1734  struct PhysicalDeviceImageProcessing2FeaturesQCOM;
1735  struct PhysicalDeviceImageProcessing2PropertiesQCOM;
1736  struct SamplerBlockMatchWindowCreateInfoQCOM;
1737
1738  //=== VK_QCOM_filter_cubic_weights ===
1739  struct PhysicalDeviceCubicWeightsFeaturesQCOM;
1740  struct SamplerCubicWeightsCreateInfoQCOM;
1741  struct BlitImageCubicWeightsInfoQCOM;
1742
1743  //=== VK_QCOM_ycbcr_degamma ===
1744  struct PhysicalDeviceYcbcrDegammaFeaturesQCOM;
1745  struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
1746
1747  //=== VK_QCOM_filter_cubic_clamp ===
1748  struct PhysicalDeviceCubicClampFeaturesQCOM;
1749
1750  //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
1751  struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
1752
1753  //=== VK_KHR_vertex_attribute_divisor ===
1754  struct PhysicalDeviceVertexAttributeDivisorPropertiesKHR;
1755  struct VertexInputBindingDivisorDescriptionKHR;
1756  using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescriptionKHR;
1757  struct PipelineVertexInputDivisorStateCreateInfoKHR;
1758  using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfoKHR;
1759  struct PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
1760  using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
1761
1762#if defined( VK_USE_PLATFORM_SCREEN_QNX )
1763  //=== VK_QNX_external_memory_screen_buffer ===
1764  struct ScreenBufferPropertiesQNX;
1765  struct ScreenBufferFormatPropertiesQNX;
1766  struct ImportScreenBufferInfoQNX;
1767  struct ExternalFormatQNX;
1768  struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
1769#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1770
1771  //=== VK_MSFT_layered_driver ===
1772  struct PhysicalDeviceLayeredDriverPropertiesMSFT;
1773
1774  //=== VK_KHR_calibrated_timestamps ===
1775  struct CalibratedTimestampInfoKHR;
1776  using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;
1777
1778  //=== VK_KHR_maintenance6 ===
1779  struct PhysicalDeviceMaintenance6FeaturesKHR;
1780  struct PhysicalDeviceMaintenance6PropertiesKHR;
1781  struct BindMemoryStatusKHR;
1782  struct BindDescriptorSetsInfoKHR;
1783  struct PushConstantsInfoKHR;
1784  struct PushDescriptorSetInfoKHR;
1785  struct PushDescriptorSetWithTemplateInfoKHR;
1786  struct SetDescriptorBufferOffsetsInfoEXT;
1787  struct BindDescriptorBufferEmbeddedSamplersInfoEXT;
1788
1789  //=== VK_NV_descriptor_pool_overallocation ===
1790  struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
1791
1792  //===================================
1793  //=== HANDLE forward declarations ===
1794  //===================================
1795
1796  //=== VK_VERSION_1_0 ===
1797  class Instance;
1798  class PhysicalDevice;
1799  class Device;
1800  class Queue;
1801  class DeviceMemory;
1802  class Fence;
1803  class Semaphore;
1804  class Event;
1805  class QueryPool;
1806  class Buffer;
1807  class BufferView;
1808  class Image;
1809  class ImageView;
1810  class ShaderModule;
1811  class PipelineCache;
1812  class Pipeline;
1813  class PipelineLayout;
1814  class Sampler;
1815  class DescriptorPool;
1816  class DescriptorSet;
1817  class DescriptorSetLayout;
1818  class Framebuffer;
1819  class RenderPass;
1820  class CommandPool;
1821  class CommandBuffer;
1822
1823  //=== VK_VERSION_1_1 ===
1824  class SamplerYcbcrConversion;
1825  class DescriptorUpdateTemplate;
1826
1827  //=== VK_VERSION_1_3 ===
1828  class PrivateDataSlot;
1829
1830  //=== VK_KHR_surface ===
1831  class SurfaceKHR;
1832
1833  //=== VK_KHR_swapchain ===
1834  class SwapchainKHR;
1835
1836  //=== VK_KHR_display ===
1837  class DisplayKHR;
1838  class DisplayModeKHR;
1839
1840  //=== VK_EXT_debug_report ===
1841  class DebugReportCallbackEXT;
1842
1843  //=== VK_KHR_video_queue ===
1844  class VideoSessionKHR;
1845  class VideoSessionParametersKHR;
1846
1847  //=== VK_NVX_binary_import ===
1848  class CuModuleNVX;
1849  class CuFunctionNVX;
1850
1851  //=== VK_EXT_debug_utils ===
1852  class DebugUtilsMessengerEXT;
1853
1854  //=== VK_KHR_acceleration_structure ===
1855  class AccelerationStructureKHR;
1856
1857  //=== VK_EXT_validation_cache ===
1858  class ValidationCacheEXT;
1859
1860  //=== VK_NV_ray_tracing ===
1861  class AccelerationStructureNV;
1862
1863  //=== VK_INTEL_performance_query ===
1864  class PerformanceConfigurationINTEL;
1865
1866  //=== VK_KHR_deferred_host_operations ===
1867  class DeferredOperationKHR;
1868
1869  //=== VK_NV_device_generated_commands ===
1870  class IndirectCommandsLayoutNV;
1871
1872#if defined( VK_ENABLE_BETA_EXTENSIONS )
1873  //=== VK_NV_cuda_kernel_launch ===
1874  class CudaModuleNV;
1875  class CudaFunctionNV;
1876#endif /*VK_ENABLE_BETA_EXTENSIONS*/
1877
1878#if defined( VK_USE_PLATFORM_FUCHSIA )
1879  //=== VK_FUCHSIA_buffer_collection ===
1880  class BufferCollectionFUCHSIA;
1881#endif /*VK_USE_PLATFORM_FUCHSIA*/
1882
1883  //=== VK_EXT_opacity_micromap ===
1884  class MicromapEXT;
1885
1886  //=== VK_NV_optical_flow ===
1887  class OpticalFlowSessionNV;
1888
1889  //=== VK_EXT_shader_object ===
1890  class ShaderEXT;
1891
1892#ifndef VULKAN_HPP_NO_SMART_HANDLE
1893  //======================
1894  //=== UNIQUE HANDLEs ===
1895  //======================
1896
1897  //=== VK_VERSION_1_0 ===
1898  template <typename Dispatch>
1899  class UniqueHandleTraits<Instance, Dispatch>
1900  {
1901  public:
1902    using deleter = ObjectDestroy<NoParent, Dispatch>;
1903  };
1904
1905  using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1906
1907  template <typename Dispatch>
1908  class UniqueHandleTraits<Device, Dispatch>
1909  {
1910  public:
1911    using deleter = ObjectDestroy<NoParent, Dispatch>;
1912  };
1913
1914  using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1915
1916  template <typename Dispatch>
1917  class UniqueHandleTraits<DeviceMemory, Dispatch>
1918  {
1919  public:
1920    using deleter = ObjectFree<Device, Dispatch>;
1921  };
1922
1923  using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1924
1925  template <typename Dispatch>
1926  class UniqueHandleTraits<Fence, Dispatch>
1927  {
1928  public:
1929    using deleter = ObjectDestroy<Device, Dispatch>;
1930  };
1931
1932  using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1933
1934  template <typename Dispatch>
1935  class UniqueHandleTraits<Semaphore, Dispatch>
1936  {
1937  public:
1938    using deleter = ObjectDestroy<Device, Dispatch>;
1939  };
1940
1941  using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1942
1943  template <typename Dispatch>
1944  class UniqueHandleTraits<Event, Dispatch>
1945  {
1946  public:
1947    using deleter = ObjectDestroy<Device, Dispatch>;
1948  };
1949
1950  using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1951
1952  template <typename Dispatch>
1953  class UniqueHandleTraits<QueryPool, Dispatch>
1954  {
1955  public:
1956    using deleter = ObjectDestroy<Device, Dispatch>;
1957  };
1958
1959  using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1960
1961  template <typename Dispatch>
1962  class UniqueHandleTraits<Buffer, Dispatch>
1963  {
1964  public:
1965    using deleter = ObjectDestroy<Device, Dispatch>;
1966  };
1967
1968  using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1969
1970  template <typename Dispatch>
1971  class UniqueHandleTraits<BufferView, Dispatch>
1972  {
1973  public:
1974    using deleter = ObjectDestroy<Device, Dispatch>;
1975  };
1976
1977  using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1978
1979  template <typename Dispatch>
1980  class UniqueHandleTraits<Image, Dispatch>
1981  {
1982  public:
1983    using deleter = ObjectDestroy<Device, Dispatch>;
1984  };
1985
1986  using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1987
1988  template <typename Dispatch>
1989  class UniqueHandleTraits<ImageView, Dispatch>
1990  {
1991  public:
1992    using deleter = ObjectDestroy<Device, Dispatch>;
1993  };
1994
1995  using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1996
1997  template <typename Dispatch>
1998  class UniqueHandleTraits<ShaderModule, Dispatch>
1999  {
2000  public:
2001    using deleter = ObjectDestroy<Device, Dispatch>;
2002  };
2003
2004  using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2005
2006  template <typename Dispatch>
2007  class UniqueHandleTraits<PipelineCache, Dispatch>
2008  {
2009  public:
2010    using deleter = ObjectDestroy<Device, Dispatch>;
2011  };
2012
2013  using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2014
2015  template <typename Dispatch>
2016  class UniqueHandleTraits<Pipeline, Dispatch>
2017  {
2018  public:
2019    using deleter = ObjectDestroy<Device, Dispatch>;
2020  };
2021
2022  using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2023
2024  template <typename Dispatch>
2025  class UniqueHandleTraits<PipelineLayout, Dispatch>
2026  {
2027  public:
2028    using deleter = ObjectDestroy<Device, Dispatch>;
2029  };
2030
2031  using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2032
2033  template <typename Dispatch>
2034  class UniqueHandleTraits<Sampler, Dispatch>
2035  {
2036  public:
2037    using deleter = ObjectDestroy<Device, Dispatch>;
2038  };
2039
2040  using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2041
2042  template <typename Dispatch>
2043  class UniqueHandleTraits<DescriptorPool, Dispatch>
2044  {
2045  public:
2046    using deleter = ObjectDestroy<Device, Dispatch>;
2047  };
2048
2049  using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2050
2051  template <typename Dispatch>
2052  class UniqueHandleTraits<DescriptorSet, Dispatch>
2053  {
2054  public:
2055    using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
2056  };
2057
2058  using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2059
2060  template <typename Dispatch>
2061  class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
2062  {
2063  public:
2064    using deleter = ObjectDestroy<Device, Dispatch>;
2065  };
2066
2067  using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2068
2069  template <typename Dispatch>
2070  class UniqueHandleTraits<Framebuffer, Dispatch>
2071  {
2072  public:
2073    using deleter = ObjectDestroy<Device, Dispatch>;
2074  };
2075
2076  using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2077
2078  template <typename Dispatch>
2079  class UniqueHandleTraits<RenderPass, Dispatch>
2080  {
2081  public:
2082    using deleter = ObjectDestroy<Device, Dispatch>;
2083  };
2084
2085  using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2086
2087  template <typename Dispatch>
2088  class UniqueHandleTraits<CommandPool, Dispatch>
2089  {
2090  public:
2091    using deleter = ObjectDestroy<Device, Dispatch>;
2092  };
2093
2094  using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2095
2096  template <typename Dispatch>
2097  class UniqueHandleTraits<CommandBuffer, Dispatch>
2098  {
2099  public:
2100    using deleter = PoolFree<Device, CommandPool, Dispatch>;
2101  };
2102
2103  using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2104
2105  //=== VK_VERSION_1_1 ===
2106  template <typename Dispatch>
2107  class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
2108  {
2109  public:
2110    using deleter = ObjectDestroy<Device, Dispatch>;
2111  };
2112
2113  using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2114  using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2115
2116  template <typename Dispatch>
2117  class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
2118  {
2119  public:
2120    using deleter = ObjectDestroy<Device, Dispatch>;
2121  };
2122
2123  using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2124  using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2125
2126  //=== VK_VERSION_1_3 ===
2127  template <typename Dispatch>
2128  class UniqueHandleTraits<PrivateDataSlot, Dispatch>
2129  {
2130  public:
2131    using deleter = ObjectDestroy<Device, Dispatch>;
2132  };
2133
2134  using UniquePrivateDataSlot    = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2135  using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2136
2137  //=== VK_KHR_surface ===
2138  template <typename Dispatch>
2139  class UniqueHandleTraits<SurfaceKHR, Dispatch>
2140  {
2141  public:
2142    using deleter = ObjectDestroy<Instance, Dispatch>;
2143  };
2144
2145  using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2146
2147  //=== VK_KHR_swapchain ===
2148  template <typename Dispatch>
2149  class UniqueHandleTraits<SwapchainKHR, Dispatch>
2150  {
2151  public:
2152    using deleter = ObjectDestroy<Device, Dispatch>;
2153  };
2154
2155  using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2156
2157  //=== VK_KHR_display ===
2158  template <typename Dispatch>
2159  class UniqueHandleTraits<DisplayKHR, Dispatch>
2160  {
2161  public:
2162    using deleter = ObjectDestroy<PhysicalDevice, Dispatch>;
2163  };
2164
2165  using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2166
2167  //=== VK_EXT_debug_report ===
2168  template <typename Dispatch>
2169  class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
2170  {
2171  public:
2172    using deleter = ObjectDestroy<Instance, Dispatch>;
2173  };
2174
2175  using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2176
2177  //=== VK_KHR_video_queue ===
2178  template <typename Dispatch>
2179  class UniqueHandleTraits<VideoSessionKHR, Dispatch>
2180  {
2181  public:
2182    using deleter = ObjectDestroy<Device, Dispatch>;
2183  };
2184
2185  using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2186
2187  template <typename Dispatch>
2188  class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
2189  {
2190  public:
2191    using deleter = ObjectDestroy<Device, Dispatch>;
2192  };
2193
2194  using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2195
2196  //=== VK_NVX_binary_import ===
2197  template <typename Dispatch>
2198  class UniqueHandleTraits<CuModuleNVX, Dispatch>
2199  {
2200  public:
2201    using deleter = ObjectDestroy<Device, Dispatch>;
2202  };
2203
2204  using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2205
2206  template <typename Dispatch>
2207  class UniqueHandleTraits<CuFunctionNVX, Dispatch>
2208  {
2209  public:
2210    using deleter = ObjectDestroy<Device, Dispatch>;
2211  };
2212
2213  using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2214
2215  //=== VK_EXT_debug_utils ===
2216  template <typename Dispatch>
2217  class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
2218  {
2219  public:
2220    using deleter = ObjectDestroy<Instance, Dispatch>;
2221  };
2222
2223  using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2224
2225  //=== VK_KHR_acceleration_structure ===
2226  template <typename Dispatch>
2227  class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
2228  {
2229  public:
2230    using deleter = ObjectDestroy<Device, Dispatch>;
2231  };
2232
2233  using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2234
2235  //=== VK_EXT_validation_cache ===
2236  template <typename Dispatch>
2237  class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
2238  {
2239  public:
2240    using deleter = ObjectDestroy<Device, Dispatch>;
2241  };
2242
2243  using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2244
2245  //=== VK_NV_ray_tracing ===
2246  template <typename Dispatch>
2247  class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
2248  {
2249  public:
2250    using deleter = ObjectDestroy<Device, Dispatch>;
2251  };
2252
2253  using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2254
2255  //=== VK_INTEL_performance_query ===
2256  template <typename Dispatch>
2257  class UniqueHandleTraits<PerformanceConfigurationINTEL, Dispatch>
2258  {
2259  public:
2260    using deleter = ObjectDestroy<Device, Dispatch>;
2261  };
2262
2263  using UniquePerformanceConfigurationINTEL = UniqueHandle<PerformanceConfigurationINTEL, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2264
2265  //=== VK_KHR_deferred_host_operations ===
2266  template <typename Dispatch>
2267  class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
2268  {
2269  public:
2270    using deleter = ObjectDestroy<Device, Dispatch>;
2271  };
2272
2273  using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2274
2275  //=== VK_NV_device_generated_commands ===
2276  template <typename Dispatch>
2277  class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
2278  {
2279  public:
2280    using deleter = ObjectDestroy<Device, Dispatch>;
2281  };
2282
2283  using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2284
2285#  if defined( VK_ENABLE_BETA_EXTENSIONS )
2286  //=== VK_NV_cuda_kernel_launch ===
2287  template <typename Dispatch>
2288  class UniqueHandleTraits<CudaModuleNV, Dispatch>
2289  {
2290  public:
2291    using deleter = ObjectDestroy<Device, Dispatch>;
2292  };
2293
2294  using UniqueCudaModuleNV = UniqueHandle<CudaModuleNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2295
2296  template <typename Dispatch>
2297  class UniqueHandleTraits<CudaFunctionNV, Dispatch>
2298  {
2299  public:
2300    using deleter = ObjectDestroy<Device, Dispatch>;
2301  };
2302
2303  using UniqueCudaFunctionNV = UniqueHandle<CudaFunctionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2304#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
2305
2306#  if defined( VK_USE_PLATFORM_FUCHSIA )
2307  //=== VK_FUCHSIA_buffer_collection ===
2308  template <typename Dispatch>
2309  class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
2310  {
2311  public:
2312    using deleter = ObjectDestroy<Device, Dispatch>;
2313  };
2314
2315  using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2316#  endif /*VK_USE_PLATFORM_FUCHSIA*/
2317
2318  //=== VK_EXT_opacity_micromap ===
2319  template <typename Dispatch>
2320  class UniqueHandleTraits<MicromapEXT, Dispatch>
2321  {
2322  public:
2323    using deleter = ObjectDestroy<Device, Dispatch>;
2324  };
2325
2326  using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2327
2328  //=== VK_NV_optical_flow ===
2329  template <typename Dispatch>
2330  class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
2331  {
2332  public:
2333    using deleter = ObjectDestroy<Device, Dispatch>;
2334  };
2335
2336  using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2337
2338  //=== VK_EXT_shader_object ===
2339  template <typename Dispatch>
2340  class UniqueHandleTraits<ShaderEXT, Dispatch>
2341  {
2342  public:
2343    using deleter = ObjectDestroy<Device, Dispatch>;
2344  };
2345
2346  using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2347#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
2348
2349  //===============
2350  //=== HANDLEs ===
2351  //===============
2352
2353  template <typename Type>
2354  struct isVulkanHandleType
2355  {
2356    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
2357  };
2358
2359  class SurfaceKHR
2360  {
2361  public:
2362    using CType      = VkSurfaceKHR;
2363    using NativeType = VkSurfaceKHR;
2364
2365    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
2366    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2367      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
2368
2369  public:
2370    VULKAN_HPP_CONSTEXPR SurfaceKHR() = default;
2371
2372    VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2373
2374    VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}
2375
2376#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2377    SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
2378    {
2379      m_surfaceKHR = surfaceKHR;
2380      return *this;
2381    }
2382#endif
2383
2384    SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2385    {
2386      m_surfaceKHR = {};
2387      return *this;
2388    }
2389
2390#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2391    auto operator<=>( SurfaceKHR const & ) const = default;
2392#else
2393    bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2394    {
2395      return m_surfaceKHR == rhs.m_surfaceKHR;
2396    }
2397
2398    bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2399    {
2400      return m_surfaceKHR != rhs.m_surfaceKHR;
2401    }
2402
2403    bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2404    {
2405      return m_surfaceKHR < rhs.m_surfaceKHR;
2406    }
2407#endif
2408
2409    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
2410    {
2411      return m_surfaceKHR;
2412    }
2413
2414    explicit operator bool() const VULKAN_HPP_NOEXCEPT
2415    {
2416      return m_surfaceKHR != VK_NULL_HANDLE;
2417    }
2418
2419    bool operator!() const VULKAN_HPP_NOEXCEPT
2420    {
2421      return m_surfaceKHR == VK_NULL_HANDLE;
2422    }
2423
2424  private:
2425    VkSurfaceKHR m_surfaceKHR = {};
2426  };
2427
2428  template <>
2429  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
2430  {
2431    using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2432  };
2433
2434  template <>
2435  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
2436  {
2437    using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2438  };
2439
2440  template <>
2441  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
2442  {
2443    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2444  };
2445
2446  class DebugReportCallbackEXT
2447  {
2448  public:
2449    using CType      = VkDebugReportCallbackEXT;
2450    using NativeType = VkDebugReportCallbackEXT;
2451
2452    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
2453    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2454      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
2455
2456  public:
2457    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default;
2458
2459    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2460
2461    VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
2462      : m_debugReportCallbackEXT( debugReportCallbackEXT )
2463    {
2464    }
2465
2466#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2467    DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
2468    {
2469      m_debugReportCallbackEXT = debugReportCallbackEXT;
2470      return *this;
2471    }
2472#endif
2473
2474    DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2475    {
2476      m_debugReportCallbackEXT = {};
2477      return *this;
2478    }
2479
2480#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2481    auto operator<=>( DebugReportCallbackEXT const & ) const = default;
2482#else
2483    bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2484    {
2485      return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
2486    }
2487
2488    bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2489    {
2490      return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
2491    }
2492
2493    bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2494    {
2495      return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
2496    }
2497#endif
2498
2499    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
2500    {
2501      return m_debugReportCallbackEXT;
2502    }
2503
2504    explicit operator bool() const VULKAN_HPP_NOEXCEPT
2505    {
2506      return m_debugReportCallbackEXT != VK_NULL_HANDLE;
2507    }
2508
2509    bool operator!() const VULKAN_HPP_NOEXCEPT
2510    {
2511      return m_debugReportCallbackEXT == VK_NULL_HANDLE;
2512    }
2513
2514  private:
2515    VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
2516  };
2517
2518  template <>
2519  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
2520  {
2521    using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2522  };
2523
2524  template <>
2525  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
2526  {
2527    using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2528  };
2529
2530  template <>
2531  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
2532  {
2533    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2534  };
2535
2536  class DebugUtilsMessengerEXT
2537  {
2538  public:
2539    using CType      = VkDebugUtilsMessengerEXT;
2540    using NativeType = VkDebugUtilsMessengerEXT;
2541
2542    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
2543    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2544      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2545
2546  public:
2547    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;
2548
2549    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2550
2551    VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
2552      : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
2553    {
2554    }
2555
2556#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2557    DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
2558    {
2559      m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
2560      return *this;
2561    }
2562#endif
2563
2564    DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2565    {
2566      m_debugUtilsMessengerEXT = {};
2567      return *this;
2568    }
2569
2570#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2571    auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
2572#else
2573    bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2574    {
2575      return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
2576    }
2577
2578    bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2579    {
2580      return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
2581    }
2582
2583    bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2584    {
2585      return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
2586    }
2587#endif
2588
2589    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
2590    {
2591      return m_debugUtilsMessengerEXT;
2592    }
2593
2594    explicit operator bool() const VULKAN_HPP_NOEXCEPT
2595    {
2596      return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
2597    }
2598
2599    bool operator!() const VULKAN_HPP_NOEXCEPT
2600    {
2601      return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
2602    }
2603
2604  private:
2605    VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
2606  };
2607
2608  template <>
2609  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
2610  {
2611    using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
2612  };
2613
2614  template <>
2615  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
2616  {
2617    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2618  };
2619
2620  class DisplayKHR
2621  {
2622  public:
2623    using CType      = VkDisplayKHR;
2624    using NativeType = VkDisplayKHR;
2625
2626    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
2627    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2628      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
2629
2630  public:
2631    VULKAN_HPP_CONSTEXPR DisplayKHR() = default;
2632
2633    VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2634
2635    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
2636
2637#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2638    DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
2639    {
2640      m_displayKHR = displayKHR;
2641      return *this;
2642    }
2643#endif
2644
2645    DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2646    {
2647      m_displayKHR = {};
2648      return *this;
2649    }
2650
2651#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2652    auto operator<=>( DisplayKHR const & ) const = default;
2653#else
2654    bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2655    {
2656      return m_displayKHR == rhs.m_displayKHR;
2657    }
2658
2659    bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2660    {
2661      return m_displayKHR != rhs.m_displayKHR;
2662    }
2663
2664    bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2665    {
2666      return m_displayKHR < rhs.m_displayKHR;
2667    }
2668#endif
2669
2670    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
2671    {
2672      return m_displayKHR;
2673    }
2674
2675    explicit operator bool() const VULKAN_HPP_NOEXCEPT
2676    {
2677      return m_displayKHR != VK_NULL_HANDLE;
2678    }
2679
2680    bool operator!() const VULKAN_HPP_NOEXCEPT
2681    {
2682      return m_displayKHR == VK_NULL_HANDLE;
2683    }
2684
2685  private:
2686    VkDisplayKHR m_displayKHR = {};
2687  };
2688
2689  template <>
2690  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
2691  {
2692    using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2693  };
2694
2695  template <>
2696  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
2697  {
2698    using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2699  };
2700
2701  template <>
2702  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
2703  {
2704    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2705  };
2706
2707  class SwapchainKHR
2708  {
2709  public:
2710    using CType      = VkSwapchainKHR;
2711    using NativeType = VkSwapchainKHR;
2712
2713    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
2714    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2715      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
2716
2717  public:
2718    VULKAN_HPP_CONSTEXPR SwapchainKHR() = default;
2719
2720    VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2721
2722    VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}
2723
2724#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2725    SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
2726    {
2727      m_swapchainKHR = swapchainKHR;
2728      return *this;
2729    }
2730#endif
2731
2732    SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2733    {
2734      m_swapchainKHR = {};
2735      return *this;
2736    }
2737
2738#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2739    auto operator<=>( SwapchainKHR const & ) const = default;
2740#else
2741    bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2742    {
2743      return m_swapchainKHR == rhs.m_swapchainKHR;
2744    }
2745
2746    bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2747    {
2748      return m_swapchainKHR != rhs.m_swapchainKHR;
2749    }
2750
2751    bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2752    {
2753      return m_swapchainKHR < rhs.m_swapchainKHR;
2754    }
2755#endif
2756
2757    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
2758    {
2759      return m_swapchainKHR;
2760    }
2761
2762    explicit operator bool() const VULKAN_HPP_NOEXCEPT
2763    {
2764      return m_swapchainKHR != VK_NULL_HANDLE;
2765    }
2766
2767    bool operator!() const VULKAN_HPP_NOEXCEPT
2768    {
2769      return m_swapchainKHR == VK_NULL_HANDLE;
2770    }
2771
2772  private:
2773    VkSwapchainKHR m_swapchainKHR = {};
2774  };
2775
2776  template <>
2777  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
2778  {
2779    using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2780  };
2781
2782  template <>
2783  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
2784  {
2785    using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2786  };
2787
2788  template <>
2789  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
2790  {
2791    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2792  };
2793
2794  class Semaphore
2795  {
2796  public:
2797    using CType      = VkSemaphore;
2798    using NativeType = VkSemaphore;
2799
2800    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
2801    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2802      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
2803
2804  public:
2805    VULKAN_HPP_CONSTEXPR Semaphore() = default;
2806
2807    VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2808
2809    VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
2810
2811#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2812    Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
2813    {
2814      m_semaphore = semaphore;
2815      return *this;
2816    }
2817#endif
2818
2819    Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2820    {
2821      m_semaphore = {};
2822      return *this;
2823    }
2824
2825#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2826    auto operator<=>( Semaphore const & ) const = default;
2827#else
2828    bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2829    {
2830      return m_semaphore == rhs.m_semaphore;
2831    }
2832
2833    bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2834    {
2835      return m_semaphore != rhs.m_semaphore;
2836    }
2837
2838    bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2839    {
2840      return m_semaphore < rhs.m_semaphore;
2841    }
2842#endif
2843
2844    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
2845    {
2846      return m_semaphore;
2847    }
2848
2849    explicit operator bool() const VULKAN_HPP_NOEXCEPT
2850    {
2851      return m_semaphore != VK_NULL_HANDLE;
2852    }
2853
2854    bool operator!() const VULKAN_HPP_NOEXCEPT
2855    {
2856      return m_semaphore == VK_NULL_HANDLE;
2857    }
2858
2859  private:
2860    VkSemaphore m_semaphore = {};
2861  };
2862
2863  template <>
2864  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
2865  {
2866    using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2867  };
2868
2869  template <>
2870  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
2871  {
2872    using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2873  };
2874
2875  template <>
2876  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
2877  {
2878    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2879  };
2880
2881  class Fence
2882  {
2883  public:
2884    using CType      = VkFence;
2885    using NativeType = VkFence;
2886
2887    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;
2888    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2889      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
2890
2891  public:
2892    VULKAN_HPP_CONSTEXPR Fence() = default;
2893
2894    VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2895
2896    VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
2897
2898#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2899    Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
2900    {
2901      m_fence = fence;
2902      return *this;
2903    }
2904#endif
2905
2906    Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2907    {
2908      m_fence = {};
2909      return *this;
2910    }
2911
2912#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2913    auto operator<=>( Fence const & ) const = default;
2914#else
2915    bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2916    {
2917      return m_fence == rhs.m_fence;
2918    }
2919
2920    bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2921    {
2922      return m_fence != rhs.m_fence;
2923    }
2924
2925    bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2926    {
2927      return m_fence < rhs.m_fence;
2928    }
2929#endif
2930
2931    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
2932    {
2933      return m_fence;
2934    }
2935
2936    explicit operator bool() const VULKAN_HPP_NOEXCEPT
2937    {
2938      return m_fence != VK_NULL_HANDLE;
2939    }
2940
2941    bool operator!() const VULKAN_HPP_NOEXCEPT
2942    {
2943      return m_fence == VK_NULL_HANDLE;
2944    }
2945
2946  private:
2947    VkFence m_fence = {};
2948  };
2949
2950  template <>
2951  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
2952  {
2953    using Type = VULKAN_HPP_NAMESPACE::Fence;
2954  };
2955
2956  template <>
2957  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
2958  {
2959    using Type = VULKAN_HPP_NAMESPACE::Fence;
2960  };
2961
2962  template <>
2963  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
2964  {
2965    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2966  };
2967
2968  class PerformanceConfigurationINTEL
2969  {
2970  public:
2971    using CType      = VkPerformanceConfigurationINTEL;
2972    using NativeType = VkPerformanceConfigurationINTEL;
2973
2974    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
2975    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2976      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2977
2978  public:
2979    VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default;
2980
2981    VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2982
2983    VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2984      : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
2985    {
2986    }
2987
2988#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2989    PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2990    {
2991      m_performanceConfigurationINTEL = performanceConfigurationINTEL;
2992      return *this;
2993    }
2994#endif
2995
2996    PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2997    {
2998      m_performanceConfigurationINTEL = {};
2999      return *this;
3000    }
3001
3002#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3003    auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
3004#else
3005    bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3006    {
3007      return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
3008    }
3009
3010    bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3011    {
3012      return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
3013    }
3014
3015    bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3016    {
3017      return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
3018    }
3019#endif
3020
3021    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
3022    {
3023      return m_performanceConfigurationINTEL;
3024    }
3025
3026    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3027    {
3028      return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
3029    }
3030
3031    bool operator!() const VULKAN_HPP_NOEXCEPT
3032    {
3033      return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
3034    }
3035
3036  private:
3037    VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
3038  };
3039
3040  template <>
3041  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
3042  {
3043    using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
3044  };
3045
3046  template <>
3047  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
3048  {
3049    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3050  };
3051
3052  class QueryPool
3053  {
3054  public:
3055    using CType      = VkQueryPool;
3056    using NativeType = VkQueryPool;
3057
3058    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
3059    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3060      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
3061
3062  public:
3063    VULKAN_HPP_CONSTEXPR QueryPool() = default;
3064
3065    VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3066
3067    VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
3068
3069#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3070    QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
3071    {
3072      m_queryPool = queryPool;
3073      return *this;
3074    }
3075#endif
3076
3077    QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3078    {
3079      m_queryPool = {};
3080      return *this;
3081    }
3082
3083#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3084    auto operator<=>( QueryPool const & ) const = default;
3085#else
3086    bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3087    {
3088      return m_queryPool == rhs.m_queryPool;
3089    }
3090
3091    bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3092    {
3093      return m_queryPool != rhs.m_queryPool;
3094    }
3095
3096    bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3097    {
3098      return m_queryPool < rhs.m_queryPool;
3099    }
3100#endif
3101
3102    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
3103    {
3104      return m_queryPool;
3105    }
3106
3107    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3108    {
3109      return m_queryPool != VK_NULL_HANDLE;
3110    }
3111
3112    bool operator!() const VULKAN_HPP_NOEXCEPT
3113    {
3114      return m_queryPool == VK_NULL_HANDLE;
3115    }
3116
3117  private:
3118    VkQueryPool m_queryPool = {};
3119  };
3120
3121  template <>
3122  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
3123  {
3124    using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3125  };
3126
3127  template <>
3128  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
3129  {
3130    using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3131  };
3132
3133  template <>
3134  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
3135  {
3136    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3137  };
3138
3139  class Buffer
3140  {
3141  public:
3142    using CType      = VkBuffer;
3143    using NativeType = VkBuffer;
3144
3145    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
3146    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3147      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
3148
3149  public:
3150    VULKAN_HPP_CONSTEXPR Buffer() = default;
3151
3152    VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3153
3154    VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
3155
3156#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3157    Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
3158    {
3159      m_buffer = buffer;
3160      return *this;
3161    }
3162#endif
3163
3164    Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3165    {
3166      m_buffer = {};
3167      return *this;
3168    }
3169
3170#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3171    auto operator<=>( Buffer const & ) const = default;
3172#else
3173    bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3174    {
3175      return m_buffer == rhs.m_buffer;
3176    }
3177
3178    bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3179    {
3180      return m_buffer != rhs.m_buffer;
3181    }
3182
3183    bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3184    {
3185      return m_buffer < rhs.m_buffer;
3186    }
3187#endif
3188
3189    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
3190    {
3191      return m_buffer;
3192    }
3193
3194    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3195    {
3196      return m_buffer != VK_NULL_HANDLE;
3197    }
3198
3199    bool operator!() const VULKAN_HPP_NOEXCEPT
3200    {
3201      return m_buffer == VK_NULL_HANDLE;
3202    }
3203
3204  private:
3205    VkBuffer m_buffer = {};
3206  };
3207
3208  template <>
3209  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
3210  {
3211    using Type = VULKAN_HPP_NAMESPACE::Buffer;
3212  };
3213
3214  template <>
3215  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
3216  {
3217    using Type = VULKAN_HPP_NAMESPACE::Buffer;
3218  };
3219
3220  template <>
3221  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
3222  {
3223    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3224  };
3225
3226  class PipelineLayout
3227  {
3228  public:
3229    using CType      = VkPipelineLayout;
3230    using NativeType = VkPipelineLayout;
3231
3232    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
3233    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3234      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
3235
3236  public:
3237    VULKAN_HPP_CONSTEXPR PipelineLayout() = default;
3238
3239    VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3240
3241    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}
3242
3243#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3244    PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
3245    {
3246      m_pipelineLayout = pipelineLayout;
3247      return *this;
3248    }
3249#endif
3250
3251    PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3252    {
3253      m_pipelineLayout = {};
3254      return *this;
3255    }
3256
3257#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3258    auto operator<=>( PipelineLayout const & ) const = default;
3259#else
3260    bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3261    {
3262      return m_pipelineLayout == rhs.m_pipelineLayout;
3263    }
3264
3265    bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3266    {
3267      return m_pipelineLayout != rhs.m_pipelineLayout;
3268    }
3269
3270    bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3271    {
3272      return m_pipelineLayout < rhs.m_pipelineLayout;
3273    }
3274#endif
3275
3276    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
3277    {
3278      return m_pipelineLayout;
3279    }
3280
3281    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3282    {
3283      return m_pipelineLayout != VK_NULL_HANDLE;
3284    }
3285
3286    bool operator!() const VULKAN_HPP_NOEXCEPT
3287    {
3288      return m_pipelineLayout == VK_NULL_HANDLE;
3289    }
3290
3291  private:
3292    VkPipelineLayout m_pipelineLayout = {};
3293  };
3294
3295  template <>
3296  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
3297  {
3298    using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3299  };
3300
3301  template <>
3302  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
3303  {
3304    using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3305  };
3306
3307  template <>
3308  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
3309  {
3310    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3311  };
3312
3313  class DescriptorSet
3314  {
3315  public:
3316    using CType      = VkDescriptorSet;
3317    using NativeType = VkDescriptorSet;
3318
3319    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
3320    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3321      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
3322
3323  public:
3324    VULKAN_HPP_CONSTEXPR DescriptorSet() = default;
3325
3326    VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3327
3328    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}
3329
3330#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3331    DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
3332    {
3333      m_descriptorSet = descriptorSet;
3334      return *this;
3335    }
3336#endif
3337
3338    DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3339    {
3340      m_descriptorSet = {};
3341      return *this;
3342    }
3343
3344#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3345    auto operator<=>( DescriptorSet const & ) const = default;
3346#else
3347    bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3348    {
3349      return m_descriptorSet == rhs.m_descriptorSet;
3350    }
3351
3352    bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3353    {
3354      return m_descriptorSet != rhs.m_descriptorSet;
3355    }
3356
3357    bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3358    {
3359      return m_descriptorSet < rhs.m_descriptorSet;
3360    }
3361#endif
3362
3363    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
3364    {
3365      return m_descriptorSet;
3366    }
3367
3368    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3369    {
3370      return m_descriptorSet != VK_NULL_HANDLE;
3371    }
3372
3373    bool operator!() const VULKAN_HPP_NOEXCEPT
3374    {
3375      return m_descriptorSet == VK_NULL_HANDLE;
3376    }
3377
3378  private:
3379    VkDescriptorSet m_descriptorSet = {};
3380  };
3381
3382  template <>
3383  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
3384  {
3385    using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3386  };
3387
3388  template <>
3389  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
3390  {
3391    using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3392  };
3393
3394  template <>
3395  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
3396  {
3397    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3398  };
3399
3400  class ImageView
3401  {
3402  public:
3403    using CType      = VkImageView;
3404    using NativeType = VkImageView;
3405
3406    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
3407    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3408      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
3409
3410  public:
3411    VULKAN_HPP_CONSTEXPR ImageView() = default;
3412
3413    VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3414
3415    VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
3416
3417#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3418    ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
3419    {
3420      m_imageView = imageView;
3421      return *this;
3422    }
3423#endif
3424
3425    ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3426    {
3427      m_imageView = {};
3428      return *this;
3429    }
3430
3431#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3432    auto operator<=>( ImageView const & ) const = default;
3433#else
3434    bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3435    {
3436      return m_imageView == rhs.m_imageView;
3437    }
3438
3439    bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3440    {
3441      return m_imageView != rhs.m_imageView;
3442    }
3443
3444    bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3445    {
3446      return m_imageView < rhs.m_imageView;
3447    }
3448#endif
3449
3450    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
3451    {
3452      return m_imageView;
3453    }
3454
3455    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3456    {
3457      return m_imageView != VK_NULL_HANDLE;
3458    }
3459
3460    bool operator!() const VULKAN_HPP_NOEXCEPT
3461    {
3462      return m_imageView == VK_NULL_HANDLE;
3463    }
3464
3465  private:
3466    VkImageView m_imageView = {};
3467  };
3468
3469  template <>
3470  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
3471  {
3472    using Type = VULKAN_HPP_NAMESPACE::ImageView;
3473  };
3474
3475  template <>
3476  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
3477  {
3478    using Type = VULKAN_HPP_NAMESPACE::ImageView;
3479  };
3480
3481  template <>
3482  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
3483  {
3484    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3485  };
3486
3487  class Pipeline
3488  {
3489  public:
3490    using CType      = VkPipeline;
3491    using NativeType = VkPipeline;
3492
3493    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
3494    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3495      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
3496
3497  public:
3498    VULKAN_HPP_CONSTEXPR Pipeline() = default;
3499
3500    VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3501
3502    VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
3503
3504#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3505    Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
3506    {
3507      m_pipeline = pipeline;
3508      return *this;
3509    }
3510#endif
3511
3512    Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3513    {
3514      m_pipeline = {};
3515      return *this;
3516    }
3517
3518#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3519    auto operator<=>( Pipeline const & ) const = default;
3520#else
3521    bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3522    {
3523      return m_pipeline == rhs.m_pipeline;
3524    }
3525
3526    bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3527    {
3528      return m_pipeline != rhs.m_pipeline;
3529    }
3530
3531    bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3532    {
3533      return m_pipeline < rhs.m_pipeline;
3534    }
3535#endif
3536
3537    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
3538    {
3539      return m_pipeline;
3540    }
3541
3542    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3543    {
3544      return m_pipeline != VK_NULL_HANDLE;
3545    }
3546
3547    bool operator!() const VULKAN_HPP_NOEXCEPT
3548    {
3549      return m_pipeline == VK_NULL_HANDLE;
3550    }
3551
3552  private:
3553    VkPipeline m_pipeline = {};
3554  };
3555
3556  template <>
3557  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
3558  {
3559    using Type = VULKAN_HPP_NAMESPACE::Pipeline;
3560  };
3561
3562  template <>
3563  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
3564  {
3565    using Type = VULKAN_HPP_NAMESPACE::Pipeline;
3566  };
3567
3568  template <>
3569  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
3570  {
3571    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3572  };
3573
3574  class ShaderEXT
3575  {
3576  public:
3577    using CType      = VkShaderEXT;
3578    using NativeType = VkShaderEXT;
3579
3580    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT;
3581    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3582      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3583
3584  public:
3585    VULKAN_HPP_CONSTEXPR ShaderEXT() = default;
3586
3587    VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3588
3589    VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {}
3590
3591#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3592    ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT
3593    {
3594      m_shaderEXT = shaderEXT;
3595      return *this;
3596    }
3597#endif
3598
3599    ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3600    {
3601      m_shaderEXT = {};
3602      return *this;
3603    }
3604
3605#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3606    auto operator<=>( ShaderEXT const & ) const = default;
3607#else
3608    bool operator==( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3609    {
3610      return m_shaderEXT == rhs.m_shaderEXT;
3611    }
3612
3613    bool operator!=( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3614    {
3615      return m_shaderEXT != rhs.m_shaderEXT;
3616    }
3617
3618    bool operator<( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3619    {
3620      return m_shaderEXT < rhs.m_shaderEXT;
3621    }
3622#endif
3623
3624    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT
3625    {
3626      return m_shaderEXT;
3627    }
3628
3629    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3630    {
3631      return m_shaderEXT != VK_NULL_HANDLE;
3632    }
3633
3634    bool operator!() const VULKAN_HPP_NOEXCEPT
3635    {
3636      return m_shaderEXT == VK_NULL_HANDLE;
3637    }
3638
3639  private:
3640    VkShaderEXT m_shaderEXT = {};
3641  };
3642
3643  template <>
3644  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT>
3645  {
3646    using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;
3647  };
3648
3649  template <>
3650  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderEXT>
3651  {
3652    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3653  };
3654
3655  class Image
3656  {
3657  public:
3658    using CType      = VkImage;
3659    using NativeType = VkImage;
3660
3661    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;
3662    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3663      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
3664
3665  public:
3666    VULKAN_HPP_CONSTEXPR Image() = default;
3667
3668    VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3669
3670    VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
3671
3672#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3673    Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
3674    {
3675      m_image = image;
3676      return *this;
3677    }
3678#endif
3679
3680    Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3681    {
3682      m_image = {};
3683      return *this;
3684    }
3685
3686#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3687    auto operator<=>( Image const & ) const = default;
3688#else
3689    bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3690    {
3691      return m_image == rhs.m_image;
3692    }
3693
3694    bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3695    {
3696      return m_image != rhs.m_image;
3697    }
3698
3699    bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3700    {
3701      return m_image < rhs.m_image;
3702    }
3703#endif
3704
3705    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
3706    {
3707      return m_image;
3708    }
3709
3710    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3711    {
3712      return m_image != VK_NULL_HANDLE;
3713    }
3714
3715    bool operator!() const VULKAN_HPP_NOEXCEPT
3716    {
3717      return m_image == VK_NULL_HANDLE;
3718    }
3719
3720  private:
3721    VkImage m_image = {};
3722  };
3723
3724  template <>
3725  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
3726  {
3727    using Type = VULKAN_HPP_NAMESPACE::Image;
3728  };
3729
3730  template <>
3731  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
3732  {
3733    using Type = VULKAN_HPP_NAMESPACE::Image;
3734  };
3735
3736  template <>
3737  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
3738  {
3739    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3740  };
3741
3742  class AccelerationStructureNV
3743  {
3744  public:
3745    using CType      = VkAccelerationStructureNV;
3746    using NativeType = VkAccelerationStructureNV;
3747
3748    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
3749    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3750      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
3751
3752  public:
3753    VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default;
3754
3755    VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3756
3757    VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
3758      : m_accelerationStructureNV( accelerationStructureNV )
3759    {
3760    }
3761
3762#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3763    AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
3764    {
3765      m_accelerationStructureNV = accelerationStructureNV;
3766      return *this;
3767    }
3768#endif
3769
3770    AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3771    {
3772      m_accelerationStructureNV = {};
3773      return *this;
3774    }
3775
3776#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3777    auto operator<=>( AccelerationStructureNV const & ) const = default;
3778#else
3779    bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3780    {
3781      return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
3782    }
3783
3784    bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3785    {
3786      return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
3787    }
3788
3789    bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3790    {
3791      return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
3792    }
3793#endif
3794
3795    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
3796    {
3797      return m_accelerationStructureNV;
3798    }
3799
3800    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3801    {
3802      return m_accelerationStructureNV != VK_NULL_HANDLE;
3803    }
3804
3805    bool operator!() const VULKAN_HPP_NOEXCEPT
3806    {
3807      return m_accelerationStructureNV == VK_NULL_HANDLE;
3808    }
3809
3810  private:
3811    VkAccelerationStructureNV m_accelerationStructureNV = {};
3812  };
3813
3814  template <>
3815  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
3816  {
3817    using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
3818  };
3819
3820  template <>
3821  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
3822  {
3823    using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
3824  };
3825
3826  template <>
3827  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
3828  {
3829    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3830  };
3831
3832  class OpticalFlowSessionNV
3833  {
3834  public:
3835    using CType      = VkOpticalFlowSessionNV;
3836    using NativeType = VkOpticalFlowSessionNV;
3837
3838    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;
3839    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3840      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3841
3842  public:
3843    VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV() = default;
3844
3845    VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3846
3847    VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
3848      : m_opticalFlowSessionNV( opticalFlowSessionNV )
3849    {
3850    }
3851
3852#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3853    OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
3854    {
3855      m_opticalFlowSessionNV = opticalFlowSessionNV;
3856      return *this;
3857    }
3858#endif
3859
3860    OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3861    {
3862      m_opticalFlowSessionNV = {};
3863      return *this;
3864    }
3865
3866#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3867    auto operator<=>( OpticalFlowSessionNV const & ) const = default;
3868#else
3869    bool operator==( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3870    {
3871      return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;
3872    }
3873
3874    bool operator!=( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3875    {
3876      return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;
3877    }
3878
3879    bool operator<( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3880    {
3881      return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;
3882    }
3883#endif
3884
3885    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
3886    {
3887      return m_opticalFlowSessionNV;
3888    }
3889
3890    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3891    {
3892      return m_opticalFlowSessionNV != VK_NULL_HANDLE;
3893    }
3894
3895    bool operator!() const VULKAN_HPP_NOEXCEPT
3896    {
3897      return m_opticalFlowSessionNV == VK_NULL_HANDLE;
3898    }
3899
3900  private:
3901    VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};
3902  };
3903
3904  template <>
3905  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV>
3906  {
3907    using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
3908  };
3909
3910  template <>
3911  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>
3912  {
3913    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3914  };
3915
3916  class DescriptorUpdateTemplate
3917  {
3918  public:
3919    using CType      = VkDescriptorUpdateTemplate;
3920    using NativeType = VkDescriptorUpdateTemplate;
3921
3922    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
3923    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3924      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
3925
3926  public:
3927    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default;
3928
3929    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3930
3931    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
3932      : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
3933    {
3934    }
3935
3936#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3937    DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
3938    {
3939      m_descriptorUpdateTemplate = descriptorUpdateTemplate;
3940      return *this;
3941    }
3942#endif
3943
3944    DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3945    {
3946      m_descriptorUpdateTemplate = {};
3947      return *this;
3948    }
3949
3950#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3951    auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
3952#else
3953    bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3954    {
3955      return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
3956    }
3957
3958    bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3959    {
3960      return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
3961    }
3962
3963    bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3964    {
3965      return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
3966    }
3967#endif
3968
3969    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
3970    {
3971      return m_descriptorUpdateTemplate;
3972    }
3973
3974    explicit operator bool() const VULKAN_HPP_NOEXCEPT
3975    {
3976      return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
3977    }
3978
3979    bool operator!() const VULKAN_HPP_NOEXCEPT
3980    {
3981      return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
3982    }
3983
3984  private:
3985    VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
3986  };
3987
3988  template <>
3989  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
3990  {
3991    using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
3992  };
3993
3994  template <>
3995  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
3996  {
3997    using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
3998  };
3999
4000  template <>
4001  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
4002  {
4003    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4004  };
4005
4006  using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
4007
4008  class Event
4009  {
4010  public:
4011    using CType      = VkEvent;
4012    using NativeType = VkEvent;
4013
4014    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
4015    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4016      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
4017
4018  public:
4019    VULKAN_HPP_CONSTEXPR Event() = default;
4020
4021    VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4022
4023    VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
4024
4025#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
4026    Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
4027    {
4028      m_event = event;
4029      return *this;
4030    }
4031#endif
4032
4033    Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4034    {
4035      m_event = {};
4036      return *this;
4037    }
4038
4039#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4040    auto operator<=>( Event const & ) const = default;
4041#else
4042    bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4043    {
4044      return m_event == rhs.m_event;
4045    }
4046
4047    bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4048    {
4049      return m_event != rhs.m_event;
4050    }
4051
4052    bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4053    {
4054      return m_event < rhs.m_event;
4055    }
4056#endif
4057
4058    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
4059    {
4060      return m_event;
4061    }
4062
4063    explicit operator bool() const VULKAN_HPP_NOEXCEPT
4064    {
4065      return m_event != VK_NULL_HANDLE;
4066    }
4067
4068    bool operator!() const VULKAN_HPP_NOEXCEPT
4069    {
4070      return m_event == VK_NULL_HANDLE;
4071    }
4072
4073  private:
4074    VkEvent m_event = {};
4075  };
4076
4077  template <>
4078  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
4079  {
4080    using Type = VULKAN_HPP_NAMESPACE::Event;
4081  };
4082
4083  template <>
4084  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
4085  {
4086    using Type = VULKAN_HPP_NAMESPACE::Event;
4087  };
4088
4089  template <>
4090  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
4091  {
4092    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4093  };
4094
4095  class AccelerationStructureKHR
4096  {
4097  public:
4098    using CType      = VkAccelerationStructureKHR;
4099    using NativeType = VkAccelerationStructureKHR;
4100
4101    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
4102    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4103      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
4104
4105  public:
4106    VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default;
4107
4108    VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4109
4110    VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4111      : m_accelerationStructureKHR( accelerationStructureKHR )
4112    {
4113    }
4114
4115#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
4116    AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4117    {
4118      m_accelerationStructureKHR = accelerationStructureKHR;
4119      return *this;
4120    }
4121#endif
4122
4123    AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4124    {
4125      m_accelerationStructureKHR = {};
4126      return *this;
4127    }
4128
4129#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4130    auto operator<=>( AccelerationStructureKHR const & ) const = default;
4131#else
4132    bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4133    {
4134      return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
4135    }
4136
4137    bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4138    {
4139      return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
4140    }
4141
4142    bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4143    {
4144      return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
4145    }
4146#endif
4147
4148    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
4149    {
4150      return m_accelerationStructureKHR;
4151    }
4152
4153    explicit operator bool() const VULKAN_HPP_NOEXCEPT
4154    {
4155      return m_accelerationStructureKHR != VK_NULL_HANDLE;
4156    }
4157
4158    bool operator!() const VULKAN_HPP_NOEXCEPT
4159    {
4160      return m_accelerationStructureKHR == VK_NULL_HANDLE;
4161    }
4162
4163  private:
4164    VkAccelerationStructureKHR m_accelerationStructureKHR = {};
4165  };
4166
4167  template <>
4168  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
4169  {
4170    using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4171  };
4172
4173  template <>
4174  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
4175  {
4176    using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4177  };
4178
4179  template <>
4180  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
4181  {
4182    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4183  };
4184
4185  class MicromapEXT
4186  {
4187  public:
4188    using CType      = VkMicromapEXT;
4189    using NativeType = VkMicromapEXT;
4190
4191    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;
4192    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4193      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4194
4195  public:
4196    VULKAN_HPP_CONSTEXPR MicromapEXT() = default;
4197
4198    VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4199
4200    VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}
4201
4202#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
4203    MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
4204    {
4205      m_micromapEXT = micromapEXT;
4206      return *this;
4207    }
4208#endif
4209
4210    MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4211    {
4212      m_micromapEXT = {};
4213      return *this;
4214    }
4215
4216#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4217    auto operator<=>( MicromapEXT const & ) const = default;
4218#else
4219    bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4220    {
4221      return m_micromapEXT == rhs.m_micromapEXT;
4222    }
4223
4224    bool operator!=( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4225    {
4226      return m_micromapEXT != rhs.m_micromapEXT;
4227    }
4228
4229    bool operator<( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4230    {
4231      return m_micromapEXT < rhs.m_micromapEXT;
4232    }
4233#endif
4234
4235    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT
4236    {
4237      return m_micromapEXT;
4238    }
4239
4240    explicit operator bool() const VULKAN_HPP_NOEXCEPT
4241    {
4242      return m_micromapEXT != VK_NULL_HANDLE;
4243    }
4244
4245    bool operator!() const VULKAN_HPP_NOEXCEPT
4246    {
4247      return m_micromapEXT == VK_NULL_HANDLE;
4248    }
4249
4250  private:
4251    VkMicromapEXT m_micromapEXT = {};
4252  };
4253
4254  template <>
4255  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT>
4256  {
4257    using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;
4258  };
4259
4260  template <>
4261  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::MicromapEXT>
4262  {
4263    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4264  };
4265
4266  class CommandBuffer
4267  {
4268  public:
4269    using CType      = VkCommandBuffer;
4270    using NativeType = VkCommandBuffer;
4271
4272    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
4273    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4274      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
4275
4276  public:
4277    VULKAN_HPP_CONSTEXPR CommandBuffer() = default;
4278
4279    VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4280
4281    CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}
4282
4283    CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
4284    {
4285      m_commandBuffer = commandBuffer;
4286      return *this;
4287    }
4288
4289    CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4290    {
4291      m_commandBuffer = {};
4292      return *this;
4293    }
4294
4295#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4296    auto operator<=>( CommandBuffer const & ) const = default;
4297#else
4298    bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4299    {
4300      return m_commandBuffer == rhs.m_commandBuffer;
4301    }
4302
4303    bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4304    {
4305      return m_commandBuffer != rhs.m_commandBuffer;
4306    }
4307
4308    bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4309    {
4310      return m_commandBuffer < rhs.m_commandBuffer;
4311    }
4312#endif
4313
4314    //=== VK_VERSION_1_0 ===
4315
4316    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4317    VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,
4318                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4319#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4320    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4321    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo,
4322                                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4323#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4324
4325#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4326    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4327    VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4328#else
4329    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4330    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4331#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4332
4333#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4334    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4335    VULKAN_HPP_NODISCARD Result reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,
4336                                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4337#else
4338    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4339    typename ResultValueType<void>::type reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
4340                                                Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4341#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4342
4343    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4344    void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
4345                       VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
4346                       Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4347
4348    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4349    void setViewport( uint32_t                               firstViewport,
4350                      uint32_t                               viewportCount,
4351                      const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4352                      Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4353#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4354    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4355    void setViewport( uint32_t                                                                       firstViewport,
4356                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
4357                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4358#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4359
4360    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4361    void setScissor( uint32_t                             firstScissor,
4362                     uint32_t                             scissorCount,
4363                     const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4364                     Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4365#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4366    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4367    void setScissor( uint32_t                                                                     firstScissor,
4368                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
4369                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4370#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4371
4372    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4373    void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4374
4375    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4376    void setDepthBias( float              depthBiasConstantFactor,
4377                       float              depthBiasClamp,
4378                       float              depthBiasSlopeFactor,
4379                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4380
4381    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4382    void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4383
4384    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4385    void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4386
4387    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4388    void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
4389                                uint32_t                               compareMask,
4390                                Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4391
4392    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4393    void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
4394                              uint32_t                               writeMask,
4395                              Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4396
4397    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4398    void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
4399                              uint32_t                               reference,
4400                              Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4401
4402    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4403    void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint     pipelineBindPoint,
4404                             VULKAN_HPP_NAMESPACE::PipelineLayout        layout,
4405                             uint32_t                                    firstSet,
4406                             uint32_t                                    descriptorSetCount,
4407                             const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
4408                             uint32_t                                    dynamicOffsetCount,
4409                             const uint32_t *                            pDynamicOffsets,
4410                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4411#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4412    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4413    void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                             pipelineBindPoint,
4414                             VULKAN_HPP_NAMESPACE::PipelineLayout                                                layout,
4415                             uint32_t                                                                            firstSet,
4416                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
4417                             VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                            dynamicOffsets,
4418                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4419#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4420
4421    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4422    void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4423                          VULKAN_HPP_NAMESPACE::DeviceSize offset,
4424                          VULKAN_HPP_NAMESPACE::IndexType  indexType,
4425                          Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4426
4427    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4428    void bindVertexBuffers( uint32_t                                 firstBinding,
4429                            uint32_t                                 bindingCount,
4430                            const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
4431                            const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4432                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4433#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4434    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4435    void bindVertexBuffers( uint32_t                                                                         firstBinding,
4436                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
4437                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
4438                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4439#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4440
4441    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4442    void draw( uint32_t           vertexCount,
4443               uint32_t           instanceCount,
4444               uint32_t           firstVertex,
4445               uint32_t           firstInstance,
4446               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4447
4448    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4449    void drawIndexed( uint32_t           indexCount,
4450                      uint32_t           instanceCount,
4451                      uint32_t           firstIndex,
4452                      int32_t            vertexOffset,
4453                      uint32_t           firstInstance,
4454                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4455
4456    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4457    void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4458                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
4459                       uint32_t                         drawCount,
4460                       uint32_t                         stride,
4461                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4462
4463    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4464    void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4465                              VULKAN_HPP_NAMESPACE::DeviceSize offset,
4466                              uint32_t                         drawCount,
4467                              uint32_t                         stride,
4468                              Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4469
4470    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4471    void dispatch( uint32_t           groupCountX,
4472                   uint32_t           groupCountY,
4473                   uint32_t           groupCountZ,
4474                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4475
4476    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4477    void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4478                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
4479                           Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4480
4481    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4482    void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
4483                     VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
4484                     uint32_t                                 regionCount,
4485                     const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
4486                     Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4487#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4488    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4489    void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                                                     srcBuffer,
4490                     VULKAN_HPP_NAMESPACE::Buffer                                                     dstBuffer,
4491                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
4492                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4493#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4494
4495    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4496    void copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
4497                    VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
4498                    VULKAN_HPP_NAMESPACE::Image             dstImage,
4499                    VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
4500                    uint32_t                                regionCount,
4501                    const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
4502                    Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4503#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4504    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4505    void copyImage( VULKAN_HPP_NAMESPACE::Image                                                     srcImage,
4506                    VULKAN_HPP_NAMESPACE::ImageLayout                                               srcImageLayout,
4507                    VULKAN_HPP_NAMESPACE::Image                                                     dstImage,
4508                    VULKAN_HPP_NAMESPACE::ImageLayout                                               dstImageLayout,
4509                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
4510                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4511#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4512
4513    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4514    void blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
4515                    VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
4516                    VULKAN_HPP_NAMESPACE::Image             dstImage,
4517                    VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
4518                    uint32_t                                regionCount,
4519                    const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
4520                    VULKAN_HPP_NAMESPACE::Filter            filter,
4521                    Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4522#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4523    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4524    void blitImage( VULKAN_HPP_NAMESPACE::Image                                                     srcImage,
4525                    VULKAN_HPP_NAMESPACE::ImageLayout                                               srcImageLayout,
4526                    VULKAN_HPP_NAMESPACE::Image                                                     dstImage,
4527                    VULKAN_HPP_NAMESPACE::ImageLayout                                               dstImageLayout,
4528                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
4529                    VULKAN_HPP_NAMESPACE::Filter                                                    filter,
4530                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4531#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4532
4533    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4534    void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
4535                            VULKAN_HPP_NAMESPACE::Image                   dstImage,
4536                            VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
4537                            uint32_t                                      regionCount,
4538                            const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
4539                            Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4540#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4541    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4542    void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                                          srcBuffer,
4543                            VULKAN_HPP_NAMESPACE::Image                                                           dstImage,
4544                            VULKAN_HPP_NAMESPACE::ImageLayout                                                     dstImageLayout,
4545                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
4546                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4547#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4548
4549    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4550    void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
4551                            VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
4552                            VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
4553                            uint32_t                                      regionCount,
4554                            const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
4555                            Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4556#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4557    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4558    void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                                           srcImage,
4559                            VULKAN_HPP_NAMESPACE::ImageLayout                                                     srcImageLayout,
4560                            VULKAN_HPP_NAMESPACE::Buffer                                                          dstBuffer,
4561                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
4562                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4563#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4564
4565    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4566    void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
4567                       VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
4568                       VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
4569                       const void *                     pData,
4570                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4571#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4572    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4573    void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer                             dstBuffer,
4574                       VULKAN_HPP_NAMESPACE::DeviceSize                         dstOffset,
4575                       VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data,
4576                       Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4577#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4578
4579    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4580    void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
4581                     VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
4582                     VULKAN_HPP_NAMESPACE::DeviceSize size,
4583                     uint32_t                         data,
4584                     Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4585
4586    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4587    void clearColorImage( VULKAN_HPP_NAMESPACE::Image                         image,
4588                          VULKAN_HPP_NAMESPACE::ImageLayout                   imageLayout,
4589                          const VULKAN_HPP_NAMESPACE::ClearColorValue *       pColor,
4590                          uint32_t                                            rangeCount,
4591                          const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
4592                          Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4593#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4594    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4595    void clearColorImage( VULKAN_HPP_NAMESPACE::Image                                                                 image,
4596                          VULKAN_HPP_NAMESPACE::ImageLayout                                                           imageLayout,
4597                          const VULKAN_HPP_NAMESPACE::ClearColorValue &                                               color,
4598                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
4599                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4600#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4601
4602    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4603    void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                          image,
4604                                 VULKAN_HPP_NAMESPACE::ImageLayout                    imageLayout,
4605                                 const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
4606                                 uint32_t                                             rangeCount,
4607                                 const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *  pRanges,
4608                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4609#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4610    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4611    void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                                                                 image,
4612                                 VULKAN_HPP_NAMESPACE::ImageLayout                                                           imageLayout,
4613                                 const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &                                        depthStencil,
4614                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
4615                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4616#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4617
4618    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4619    void clearAttachments( uint32_t                                      attachmentCount,
4620                           const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
4621                           uint32_t                                      rectCount,
4622                           const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
4623                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4624#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4625    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4626    void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
4627                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
4628                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4629#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4630
4631    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4632    void resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,
4633                       VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,
4634                       VULKAN_HPP_NAMESPACE::Image                dstImage,
4635                       VULKAN_HPP_NAMESPACE::ImageLayout          dstImageLayout,
4636                       uint32_t                                   regionCount,
4637                       const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
4638                       Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4639#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4640    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4641    void resolveImage( VULKAN_HPP_NAMESPACE::Image                                                        srcImage,
4642                       VULKAN_HPP_NAMESPACE::ImageLayout                                                  srcImageLayout,
4643                       VULKAN_HPP_NAMESPACE::Image                                                        dstImage,
4644                       VULKAN_HPP_NAMESPACE::ImageLayout                                                  dstImageLayout,
4645                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
4646                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4647#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4648
4649    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4650    void setEvent( VULKAN_HPP_NAMESPACE::Event              event,
4651                   VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
4652                   Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4653
4654    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4655    void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
4656                     VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
4657                     Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4658
4659    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4660    void waitEvents( uint32_t                                          eventCount,
4661                     const VULKAN_HPP_NAMESPACE::Event *               pEvents,
4662                     VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
4663                     VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
4664                     uint32_t                                          memoryBarrierCount,
4665                     const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
4666                     uint32_t                                          bufferMemoryBarrierCount,
4667                     const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
4668                     uint32_t                                          imageMemoryBarrierCount,
4669                     const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
4670                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4671#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4672    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4673    void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
4674                     VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  srcStageMask,
4675                     VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  dstStageMask,
4676                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
4677                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
4678                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
4679                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4680#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4681
4682    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4683    void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
4684                          VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
4685                          VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
4686                          uint32_t                                          memoryBarrierCount,
4687                          const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
4688                          uint32_t                                          bufferMemoryBarrierCount,
4689                          const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
4690                          uint32_t                                          imageMemoryBarrierCount,
4691                          const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
4692                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4693#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4694    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4695    void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  srcStageMask,
4696                          VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  dstStageMask,
4697                          VULKAN_HPP_NAMESPACE::DependencyFlags                                                     dependencyFlags,
4698                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
4699                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
4700                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
4701                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4702#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4703
4704    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4705    void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
4706                     uint32_t                                query,
4707                     VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
4708                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4709
4710    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4711    void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
4712                   uint32_t                        query,
4713                   Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4714
4715    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4716    void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
4717                         uint32_t                        firstQuery,
4718                         uint32_t                        queryCount,
4719                         Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4720
4721    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4722    void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
4723                         VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
4724                         uint32_t                                    query,
4725                         Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4726
4727    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4728    void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
4729                               uint32_t                               firstQuery,
4730                               uint32_t                               queryCount,
4731                               VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
4732                               VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
4733                               VULKAN_HPP_NAMESPACE::DeviceSize       stride,
4734                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
4735                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4736
4737    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4738    void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
4739                        VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
4740                        uint32_t                               offset,
4741                        uint32_t                               size,
4742                        const void *                           pValues,
4743                        Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4744#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4745    template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4746    void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout                       layout,
4747                        VULKAN_HPP_NAMESPACE::ShaderStageFlags                     stageFlags,
4748                        uint32_t                                                   offset,
4749                        VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values,
4750                        Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4751#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4752
4753    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4754    void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
4755                          VULKAN_HPP_NAMESPACE::SubpassContents             contents,
4756                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4757#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4758    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4759    void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
4760                          VULKAN_HPP_NAMESPACE::SubpassContents             contents,
4761                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4762#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4763
4764    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4765    void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4766
4767    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4768    void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4769
4770    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4771    void executeCommands( uint32_t                                    commandBufferCount,
4772                          const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
4773                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4774#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4775    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4776    void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
4777                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4778#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4779
4780    //=== VK_VERSION_1_1 ===
4781
4782    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4783    void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4784
4785    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4786    void dispatchBase( uint32_t           baseGroupX,
4787                       uint32_t           baseGroupY,
4788                       uint32_t           baseGroupZ,
4789                       uint32_t           groupCountX,
4790                       uint32_t           groupCountY,
4791                       uint32_t           groupCountZ,
4792                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4793
4794    //=== VK_VERSION_1_2 ===
4795
4796    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4797    void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4798                            VULKAN_HPP_NAMESPACE::DeviceSize offset,
4799                            VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
4800                            VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4801                            uint32_t                         maxDrawCount,
4802                            uint32_t                         stride,
4803                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4804
4805    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4806    void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4807                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,
4808                                   VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
4809                                   VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4810                                   uint32_t                         maxDrawCount,
4811                                   uint32_t                         stride,
4812                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4813
4814    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4815    void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
4816                           const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
4817                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4818#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4819    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4820    void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
4821                           const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
4822                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4823#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4824
4825    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4826    void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
4827                       const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
4828                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4829#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4830    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4831    void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
4832                       const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
4833                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4834#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4835
4836    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4837    void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
4838                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4839#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4840    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4841    void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
4842                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4843#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4844
4845    //=== VK_VERSION_1_3 ===
4846
4847    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4848    void setEvent2( VULKAN_HPP_NAMESPACE::Event                  event,
4849                    const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
4850                    Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4851#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4852    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4853    void setEvent2( VULKAN_HPP_NAMESPACE::Event                  event,
4854                    const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
4855                    Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4856#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4857
4858    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4859    void resetEvent2( VULKAN_HPP_NAMESPACE::Event               event,
4860                      VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,
4861                      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4862
4863    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4864    void waitEvents2( uint32_t                                     eventCount,
4865                      const VULKAN_HPP_NAMESPACE::Event *          pEvents,
4866                      const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
4867                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4868#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4869    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4870    void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &          events,
4871                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,
4872                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4873#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4874
4875    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4876    void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
4877                           Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4878#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4879    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4880    void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
4881                           Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4882#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4883
4884    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4885    void writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
4886                          VULKAN_HPP_NAMESPACE::QueryPool           queryPool,
4887                          uint32_t                                  query,
4888                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4889
4890    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4891    void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
4892                      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4893#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4894    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4895    void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
4896                      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4897#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4898
4899    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4900    void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
4901                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4902#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4903    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4904    void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
4905                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4906#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4907
4908    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4909    void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
4910                             Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4911#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4912    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4913    void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
4914                             Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4915#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4916
4917    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4918    void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
4919                             Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4920#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4921    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4922    void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
4923                             Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4924#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4925
4926    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4927    void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
4928                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4929#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4930    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4931    void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
4932                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4933#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4934
4935    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4936    void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
4937                        Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4938#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4939    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4940    void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
4941                        Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4942#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4943
4944    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4945    void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
4946                         Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4947#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4948    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4949    void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
4950                         Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4951#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4952
4953    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4954    void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4955
4956    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4957    void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4958
4959    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4960    void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4961
4962    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4963    void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
4964                               Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4965
4966    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4967    void setViewportWithCount( uint32_t                               viewportCount,
4968                               const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4969                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4970#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4971    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4972    void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
4973                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4974#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4975
4976    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4977    void setScissorWithCount( uint32_t                             scissorCount,
4978                              const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4979                              Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4980#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4981    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4982    void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
4983                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4984#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4985
4986    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4987    void bindVertexBuffers2( uint32_t                                 firstBinding,
4988                             uint32_t                                 bindingCount,
4989                             const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
4990                             const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4991                             const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
4992                             const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
4993                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4994#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4995    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4996    void bindVertexBuffers2(
4997      uint32_t                                                                                 firstBinding,
4998      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
4999      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
5000      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5001      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5002      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5003#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5004
5005    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5006    void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
5007                             Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5008
5009    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5010    void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
5011                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5012
5013    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5014    void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
5015                            Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5016
5017    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5018    void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
5019                                   Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5020
5021    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5022    void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
5023                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5024
5025    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5026    void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5027                       VULKAN_HPP_NAMESPACE::StencilOp        failOp,
5028                       VULKAN_HPP_NAMESPACE::StencilOp        passOp,
5029                       VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
5030                       VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
5031                       Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5032
5033    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5034    void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
5035                                     Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5036
5037    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5038    void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
5039                             Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5040
5041    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5042    void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
5043                                    Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5044
5045    //=== VK_EXT_debug_marker ===
5046
5047    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5048    void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
5049                              Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5050#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5051    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5052    void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
5053                              Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5054#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5055
5056    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5057    void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5058
5059    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5060    void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
5061                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5062#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5063    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5064    void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
5065                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5066#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5067
5068    //=== VK_KHR_video_queue ===
5069
5070    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5071    void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
5072                              Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5073#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5074    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5075    void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo,
5076                              Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5077#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5078
5079    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5080    void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
5081                            Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5082#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5083    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5084    void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo,
5085                            Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5086#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5087
5088    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5089    void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
5090                                Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5091#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5092    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5093    void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo,
5094                                Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5095#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5096
5097    //=== VK_KHR_video_decode_queue ===
5098
5099    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5100    void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo,
5101                         Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5102#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5103    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5104    void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo,
5105                         Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5106#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5107
5108    //=== VK_EXT_transform_feedback ===
5109
5110    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5111    void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
5112                                          uint32_t                                 bindingCount,
5113                                          const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
5114                                          const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5115                                          const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
5116                                          Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5117#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5118    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5119    void bindTransformFeedbackBuffersEXT( uint32_t                                                                         firstBinding,
5120                                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
5121                                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5122                                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes
5123                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5124                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5125#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5126
5127    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5128    void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
5129                                    uint32_t                                 counterBufferCount,
5130                                    const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
5131                                    const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
5132                                    Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5133#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5134    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5135    void beginTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,
5136                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5137                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5138                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5139                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5140#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5141
5142    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5143    void endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
5144                                  uint32_t                                 counterBufferCount,
5145                                  const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
5146                                  const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
5147                                  Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5148#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5149    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5150    void endTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,
5151                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5152                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5153                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5154                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5155#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5156
5157    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5158    void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
5159                               uint32_t                                query,
5160                               VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
5161                               uint32_t                                index,
5162                               Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5163
5164    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5165    void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5166                             uint32_t                        query,
5167                             uint32_t                        index,
5168                             Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5169
5170    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5171    void drawIndirectByteCountEXT( uint32_t                         instanceCount,
5172                                   uint32_t                         firstInstance,
5173                                   VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
5174                                   VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
5175                                   uint32_t                         counterOffset,
5176                                   uint32_t                         vertexStride,
5177                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5178
5179    //=== VK_NVX_binary_import ===
5180
5181    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5182    void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
5183                            Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5184#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5185    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5186    void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo,
5187                            Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5188#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5189
5190    //=== VK_AMD_draw_indirect_count ===
5191
5192    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5193    void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5194                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
5195                               VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5196                               VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5197                               uint32_t                         maxDrawCount,
5198                               uint32_t                         stride,
5199                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5200
5201    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5202    void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5203                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
5204                                      VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5205                                      VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5206                                      uint32_t                         maxDrawCount,
5207                                      uint32_t                         stride,
5208                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5209
5210    //=== VK_KHR_dynamic_rendering ===
5211
5212    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5213    void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
5214                            Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5215#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5216    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5217    void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
5218                            Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5219#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5220
5221    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5222    void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5223
5224    //=== VK_KHR_device_group ===
5225
5226    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5227    void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5228
5229    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5230    void dispatchBaseKHR( uint32_t           baseGroupX,
5231                          uint32_t           baseGroupY,
5232                          uint32_t           baseGroupZ,
5233                          uint32_t           groupCountX,
5234                          uint32_t           groupCountY,
5235                          uint32_t           groupCountZ,
5236                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5237
5238    //=== VK_KHR_push_descriptor ===
5239
5240    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5241    void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
5242                               VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
5243                               uint32_t                                         set,
5244                               uint32_t                                         descriptorWriteCount,
5245                               const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
5246                               Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5247#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5248    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5249    void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                                  pipelineBindPoint,
5250                               VULKAN_HPP_NAMESPACE::PipelineLayout                                                     layout,
5251                               uint32_t                                                                                 set,
5252                               VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
5253                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5254#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5255
5256    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5257    void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5258                                           VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
5259                                           uint32_t                                       set,
5260                                           const void *                                   pData,
5261                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5262#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5263    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5264    void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5265                                           VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
5266                                           uint32_t                                       set,
5267                                           DataType const &                               data,
5268                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5269#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5270
5271    //=== VK_EXT_conditional_rendering ===
5272
5273    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5274    void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
5275                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5276#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5277    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5278    void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
5279                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5280#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5281
5282    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5283    void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5284
5285    //=== VK_NV_clip_space_w_scaling ===
5286
5287    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5288    void setViewportWScalingNV( uint32_t                                         firstViewport,
5289                                uint32_t                                         viewportCount,
5290                                const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
5291                                Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5292#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5293    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5294    void setViewportWScalingNV( uint32_t                                                                                 firstViewport,
5295                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
5296                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5297#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5298
5299    //=== VK_EXT_discard_rectangles ===
5300
5301    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5302    void setDiscardRectangleEXT( uint32_t                             firstDiscardRectangle,
5303                                 uint32_t                             discardRectangleCount,
5304                                 const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
5305                                 Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5306#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5307    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5308    void setDiscardRectangleEXT( uint32_t                                                                     firstDiscardRectangle,
5309                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
5310                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5311#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5312
5313    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5314    void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable,
5315                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5316
5317    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5318    void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode,
5319                                     Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5320
5321    //=== VK_KHR_create_renderpass2 ===
5322
5323    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5324    void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
5325                              const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
5326                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5327#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5328    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5329    void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5330                              const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
5331                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5332#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5333
5334    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5335    void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
5336                          const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
5337                          Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5338#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5339    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5340    void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5341                          const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
5342                          Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5343#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5344
5345    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5346    void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
5347                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5348#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5349    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5350    void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
5351                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5352#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5353
5354    //=== VK_EXT_debug_utils ===
5355
5356    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5357    void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
5358                                  Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5359#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5360    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5361    void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
5362                                  Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5363#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5364
5365    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5366    void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5367
5368    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5369    void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
5370                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5371#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5372    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5373    void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
5374                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5375#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5376
5377#if defined( VK_ENABLE_BETA_EXTENSIONS )
5378    //=== VK_AMDX_shader_enqueue ===
5379
5380    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5381    void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
5382                                           Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5383
5384    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5385    void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
5386                            const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,
5387                            Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5388#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5389    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5390    void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
5391                            const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,
5392                            Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5393#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5394
5395    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5396    void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
5397                                    const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,
5398                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5399#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5400    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5401    void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
5402                                    const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,
5403                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5404#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5405
5406    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5407    void dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
5408                                         VULKAN_HPP_NAMESPACE::DeviceAddress countInfo,
5409                                         Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5410#endif /*VK_ENABLE_BETA_EXTENSIONS*/
5411
5412    //=== VK_EXT_sample_locations ===
5413
5414    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5415    void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
5416                                Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5417#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5418    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5419    void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo,
5420                                Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5421#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5422
5423    //=== VK_KHR_acceleration_structure ===
5424
5425    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5426    void buildAccelerationStructuresKHR( uint32_t                                                                     infoCount,
5427                                         const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
5428                                         const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
5429                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5430#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5431    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5432    void buildAccelerationStructuresKHR(
5433      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
5434      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
5435      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5436#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5437
5438    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5439    void buildAccelerationStructuresIndirectKHR( uint32_t                                                                infoCount,
5440                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
5441                                                 const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
5442                                                 const uint32_t *                                                        pIndirectStrides,
5443                                                 const uint32_t * const *                                                ppMaxPrimitiveCounts,
5444                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5445#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5446    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5447    void buildAccelerationStructuresIndirectKHR(
5448      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
5449      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
5450      VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                                                        indirectStrides,
5451      VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
5452      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5453#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5454
5455    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5456    void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
5457                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5458#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5459    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5460    void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
5461                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5462#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5463
5464    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5465    void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
5466                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5467#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5468    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5469    void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
5470                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5471#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5472
5473    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5474    void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
5475                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5476#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5477    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5478    void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
5479                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5480#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5481
5482    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5483    void writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,
5484                                                   const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
5485                                                   VULKAN_HPP_NAMESPACE::QueryType                        queryType,
5486                                                   VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,
5487                                                   uint32_t                                               firstQuery,
5488                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5489#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5490    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5491    void writeAccelerationStructuresPropertiesKHR(
5492      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
5493      VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,
5494      VULKAN_HPP_NAMESPACE::QueryPool                                                                queryPool,
5495      uint32_t                                                                                       firstQuery,
5496      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5497#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5498
5499    //=== VK_KHR_ray_tracing_pipeline ===
5500
5501    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5502    void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5503                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5504                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5505                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5506                       uint32_t                                                    width,
5507                       uint32_t                                                    height,
5508                       uint32_t                                                    depth,
5509                       Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5510#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5511    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5512    void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5513                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5514                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5515                       const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5516                       uint32_t                                                    width,
5517                       uint32_t                                                    height,
5518                       uint32_t                                                    depth,
5519                       Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5520#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5521
5522    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5523    void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5524                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5525                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5526                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5527                               VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
5528                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5529#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5530    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5531    void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5532                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5533                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5534                               const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5535                               VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
5536                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5537#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5538
5539    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5540    void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5541
5542    //=== VK_NV_shading_rate_image ===
5543
5544    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5545    void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
5546                                 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
5547                                 Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5548
5549    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5550    void setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,
5551                                          uint32_t                                           viewportCount,
5552                                          const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
5553                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5554#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5555    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5556    void setViewportShadingRatePaletteNV( uint32_t                                                                                   firstViewport,
5557                                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
5558                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5559#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5560
5561    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5562    void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,
5563                                 uint32_t                                                customSampleOrderCount,
5564                                 const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
5565                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5566#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5567    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5568    void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                                                   sampleOrderType,
5569                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
5570                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5571#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5572
5573    //=== VK_NV_ray_tracing ===
5574
5575    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5576    void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
5577                                       VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
5578                                       VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
5579                                       VULKAN_HPP_NAMESPACE::Bool32                              update,
5580                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
5581                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
5582                                       VULKAN_HPP_NAMESPACE::Buffer                              scratch,
5583                                       VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
5584                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5585#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5586    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5587    void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
5588                                       VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
5589                                       VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
5590                                       VULKAN_HPP_NAMESPACE::Bool32                              update,
5591                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
5592                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
5593                                       VULKAN_HPP_NAMESPACE::Buffer                              scratch,
5594                                       VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
5595                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5596#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5597
5598    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5599    void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
5600                                      VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
5601                                      VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
5602                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5603
5604    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5605    void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
5606                      VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
5607                      VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
5608                      VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
5609                      VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
5610                      VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
5611                      VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
5612                      VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
5613                      VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
5614                      VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
5615                      VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
5616                      uint32_t                         width,
5617                      uint32_t                         height,
5618                      uint32_t                         depth,
5619                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5620
5621    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5622    void writeAccelerationStructuresPropertiesNV( uint32_t                                              accelerationStructureCount,
5623                                                  const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
5624                                                  VULKAN_HPP_NAMESPACE::QueryType                       queryType,
5625                                                  VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,
5626                                                  uint32_t                                              firstQuery,
5627                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5628#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5629    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5630    void writeAccelerationStructuresPropertiesNV(
5631      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
5632      VULKAN_HPP_NAMESPACE::QueryType                                                               queryType,
5633      VULKAN_HPP_NAMESPACE::QueryPool                                                               queryPool,
5634      uint32_t                                                                                      firstQuery,
5635      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5636#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5637
5638    //=== VK_KHR_draw_indirect_count ===
5639
5640    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5641    void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5642                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
5643                               VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5644                               VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5645                               uint32_t                         maxDrawCount,
5646                               uint32_t                         stride,
5647                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5648
5649    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5650    void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5651                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
5652                                      VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5653                                      VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5654                                      uint32_t                         maxDrawCount,
5655                                      uint32_t                         stride,
5656                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5657
5658    //=== VK_AMD_buffer_marker ===
5659
5660    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5661    void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
5662                               VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
5663                               VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
5664                               uint32_t                                    marker,
5665                               Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5666
5667    //=== VK_NV_mesh_shader ===
5668
5669    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5670    void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5671
5672    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5673    void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5674                                  VULKAN_HPP_NAMESPACE::DeviceSize offset,
5675                                  uint32_t                         drawCount,
5676                                  uint32_t                         stride,
5677                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5678
5679    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5680    void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5681                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
5682                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5683                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5684                                       uint32_t                         maxDrawCount,
5685                                       uint32_t                         stride,
5686                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5687
5688    //=== VK_NV_scissor_exclusive ===
5689
5690    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5691    void setExclusiveScissorEnableNV( uint32_t                             firstExclusiveScissor,
5692                                      uint32_t                             exclusiveScissorCount,
5693                                      const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables,
5694                                      Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5695#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5696    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5697    void setExclusiveScissorEnableNV( uint32_t                                                                     firstExclusiveScissor,
5698                                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables,
5699                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5700#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5701
5702    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5703    void setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,
5704                                uint32_t                             exclusiveScissorCount,
5705                                const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
5706                                Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5707#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5708    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5709    void setExclusiveScissorNV( uint32_t                                                                     firstExclusiveScissor,
5710                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
5711                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5712#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5713
5714    //=== VK_NV_device_diagnostic_checkpoints ===
5715
5716    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5717    void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5718#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5719    template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5720    void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,
5721                          Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5722#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5723
5724    //=== VK_INTEL_performance_query ===
5725
5726    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5727    VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
5728                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5729#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5730    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5731    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
5732      setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo,
5733                                 Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5734#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5735
5736    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5737    VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
5738                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5739#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5740    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5741    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
5742      setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo,
5743                                       Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5744#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5745
5746    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5747    VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
5748                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5749#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5750    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5751    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
5752      setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo,
5753                                   Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5754#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5755
5756    //=== VK_KHR_fragment_shading_rate ===
5757
5758    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5759    void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
5760                                    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
5761                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5762#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5763    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5764    void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D &                       fragmentSize,
5765                                    const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
5766                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5767#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5768
5769    //=== VK_EXT_line_rasterization ===
5770
5771    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5772    void setLineStippleEXT( uint32_t           lineStippleFactor,
5773                            uint16_t           lineStipplePattern,
5774                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5775
5776    //=== VK_EXT_extended_dynamic_state ===
5777
5778    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5779    void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5780
5781    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5782    void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5783
5784    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5785    void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
5786                                  Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5787
5788    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5789    void setViewportWithCountEXT( uint32_t                               viewportCount,
5790                                  const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
5791                                  Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5792#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5793    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5794    void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
5795                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5796#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5797
5798    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5799    void setScissorWithCountEXT( uint32_t                             scissorCount,
5800                                 const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
5801                                 Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5802#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5803    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5804    void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
5805                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5806#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5807
5808    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5809    void bindVertexBuffers2EXT( uint32_t                                 firstBinding,
5810                                uint32_t                                 bindingCount,
5811                                const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
5812                                const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5813                                const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
5814                                const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
5815                                Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5816#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5817    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5818    void bindVertexBuffers2EXT(
5819      uint32_t                                                                                 firstBinding,
5820      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
5821      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
5822      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5823      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5824      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5825#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5826
5827    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5828    void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
5829                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5830
5831    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5832    void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
5833                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5834
5835    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5836    void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
5837                               Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5838
5839    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5840    void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
5841                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5842
5843    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5844    void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
5845                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5846
5847    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5848    void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5849                          VULKAN_HPP_NAMESPACE::StencilOp        failOp,
5850                          VULKAN_HPP_NAMESPACE::StencilOp        passOp,
5851                          VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
5852                          VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
5853                          Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5854
5855    //=== VK_NV_device_generated_commands ===
5856
5857    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5858    void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
5859                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5860#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5861    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5862    void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
5863                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5864#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5865
5866    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5867    void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
5868                                     const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
5869                                     Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5870#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5871    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5872    void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
5873                                     const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
5874                                     Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5875#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5876
5877    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5878    void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
5879                                    VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
5880                                    uint32_t                                groupIndex,
5881                                    Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5882
5883    //=== VK_EXT_depth_bias_control ===
5884
5885    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5886    void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT * pDepthBiasInfo,
5887                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5888#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5889    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5890    void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo,
5891                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5892#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5893
5894    //=== VK_KHR_video_encode_queue ===
5895
5896    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5897    void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
5898                         Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5899#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5900    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5901    void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo,
5902                         Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5903#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5904
5905#if defined( VK_ENABLE_BETA_EXTENSIONS )
5906    //=== VK_NV_cuda_kernel_launch ===
5907
5908    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5909    void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV * pLaunchInfo,
5910                             Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5911#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5912    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5913    void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo,
5914                             Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5915#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5916#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
5917
5918    //=== VK_KHR_synchronization2 ===
5919
5920    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5921    void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
5922                       const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
5923                       Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5924#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5925    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5926    void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
5927                       const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
5928                       Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5929#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5930
5931    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5932    void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event               event,
5933                         VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,
5934                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5935
5936    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5937    void waitEvents2KHR( uint32_t                                     eventCount,
5938                         const VULKAN_HPP_NAMESPACE::Event *          pEvents,
5939                         const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
5940                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5941#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5942    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5943    void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &          events,
5944                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,
5945                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5946#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5947
5948    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5949    void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
5950                              Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5951#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5952    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5953    void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
5954                              Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5955#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5956
5957    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5958    void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
5959                             VULKAN_HPP_NAMESPACE::QueryPool           queryPool,
5960                             uint32_t                                  query,
5961                             Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5962
5963    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5964    void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
5965                                VULKAN_HPP_NAMESPACE::Buffer              dstBuffer,
5966                                VULKAN_HPP_NAMESPACE::DeviceSize          dstOffset,
5967                                uint32_t                                  marker,
5968                                Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5969
5970    //=== VK_EXT_descriptor_buffer ===
5971
5972    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5973    void bindDescriptorBuffersEXT( uint32_t                                                     bufferCount,
5974                                   const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos,
5975                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5976#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5977    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5978    void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos,
5979                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5980#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5981
5982    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5983    void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint  pipelineBindPoint,
5984                                        VULKAN_HPP_NAMESPACE::PipelineLayout     layout,
5985                                        uint32_t                                 firstSet,
5986                                        uint32_t                                 setCount,
5987                                        const uint32_t *                         pBufferIndices,
5988                                        const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5989                                        Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5990#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5991    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5992    void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                          pipelineBindPoint,
5993                                        VULKAN_HPP_NAMESPACE::PipelineLayout                                             layout,
5994                                        uint32_t                                                                         firstSet,
5995                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                         bufferIndices,
5996                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5997                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5998#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5999
6000    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6001    void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6002                                                  VULKAN_HPP_NAMESPACE::PipelineLayout    layout,
6003                                                  uint32_t                                set,
6004                                                  Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6005
6006    //=== VK_NV_fragment_shading_rate_enums ===
6007
6008    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6009    void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
6010                                       const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
6011                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6012
6013    //=== VK_EXT_mesh_shader ===
6014
6015    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6016    void drawMeshTasksEXT( uint32_t           groupCountX,
6017                           uint32_t           groupCountY,
6018                           uint32_t           groupCountZ,
6019                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6020
6021    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6022    void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6023                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,
6024                                   uint32_t                         drawCount,
6025                                   uint32_t                         stride,
6026                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6027
6028    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6029    void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6030                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
6031                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
6032                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
6033                                        uint32_t                         maxDrawCount,
6034                                        uint32_t                         stride,
6035                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6036
6037    //=== VK_KHR_copy_commands2 ===
6038
6039    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6040    void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
6041                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6042#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6043    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6044    void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
6045                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6046#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6047
6048    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6049    void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
6050                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6051#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6052    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6053    void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
6054                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6055#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6056
6057    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6058    void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
6059                                Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6060#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6061    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6062    void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
6063                                Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6064#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6065
6066    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6067    void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
6068                                Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6069#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6070    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6071    void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
6072                                Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6073#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6074
6075    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6076    void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
6077                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6078#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6079    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6080    void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
6081                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6082#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6083
6084    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6085    void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
6086                           Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6087#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6088    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6089    void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
6090                           Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6091#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6092
6093    //=== VK_EXT_vertex_input_dynamic_state ===
6094
6095    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6096    void setVertexInputEXT( uint32_t                                                          vertexBindingDescriptionCount,
6097                            const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT *   pVertexBindingDescriptions,
6098                            uint32_t                                                          vertexAttributeDescriptionCount,
6099                            const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
6100                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6101#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6102    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6103    void
6104      setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
6105                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
6106                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6107#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6108
6109    //=== VK_HUAWEI_subpass_shading ===
6110
6111    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6112    void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6113
6114    //=== VK_HUAWEI_invocation_mask ===
6115
6116    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6117    void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView   imageView,
6118                                   VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
6119                                   Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6120
6121    //=== VK_EXT_extended_dynamic_state2 ===
6122
6123    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6124    void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6125
6126    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6127    void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
6128                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6129
6130    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6131    void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
6132                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6133
6134    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6135    void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6136
6137    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6138    void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
6139                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6140
6141    //=== VK_EXT_color_write_enable ===
6142
6143    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6144    void setColorWriteEnableEXT( uint32_t                             attachmentCount,
6145                                 const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
6146                                 Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6147#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6148    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6149    void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
6150                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6151#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6152
6153    //=== VK_KHR_ray_tracing_maintenance1 ===
6154
6155    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6156    void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
6157                                Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6158
6159    //=== VK_EXT_multi_draw ===
6160
6161    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6162    void drawMultiEXT( uint32_t                                       drawCount,
6163                       const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,
6164                       uint32_t                                       instanceCount,
6165                       uint32_t                                       firstInstance,
6166                       uint32_t                                       stride,
6167                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6168#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6169    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6170    void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
6171                       uint32_t                                                                                      instanceCount,
6172                       uint32_t                                                                                      firstInstance,
6173                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6174#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6175
6176    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6177    void drawMultiIndexedEXT( uint32_t                                              drawCount,
6178                              const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,
6179                              uint32_t                                              instanceCount,
6180                              uint32_t                                              firstInstance,
6181                              uint32_t                                              stride,
6182                              const int32_t *                                       pVertexOffset,
6183                              Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6184#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6185    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6186    void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
6187                              uint32_t                                                                                             instanceCount,
6188                              uint32_t                                                                                             firstInstance,
6189                              Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6190                              Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6191#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6192
6193    //=== VK_EXT_opacity_micromap ===
6194
6195    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6196    void buildMicromapsEXT( uint32_t                                           infoCount,
6197                            const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,
6198                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6199#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6200    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6201    void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,
6202                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6203#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6204
6205    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6206    void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,
6207                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6208#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6209    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6210    void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,
6211                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6212#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6213
6214    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6215    void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,
6216                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6217#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6218    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6219    void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,
6220                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6221#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6222
6223    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6224    void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,
6225                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6226#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6227    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6228    void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,
6229                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6230#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6231
6232    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6233    void writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,
6234                                      const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
6235                                      VULKAN_HPP_NAMESPACE::QueryType           queryType,
6236                                      VULKAN_HPP_NAMESPACE::QueryPool           queryPool,
6237                                      uint32_t                                  firstQuery,
6238                                      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6239#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6240    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6241    void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
6242                                      VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,
6243                                      VULKAN_HPP_NAMESPACE::QueryPool                                                   queryPool,
6244                                      uint32_t                                                                          firstQuery,
6245                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6246#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6247
6248    //=== VK_HUAWEI_cluster_culling_shader ===
6249
6250    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6251    void drawClusterHUAWEI( uint32_t           groupCountX,
6252                            uint32_t           groupCountY,
6253                            uint32_t           groupCountZ,
6254                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6255
6256    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6257    void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6258                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
6259                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6260
6261    //=== VK_NV_copy_memory_indirect ===
6262
6263    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6264    void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,
6265                               uint32_t                            copyCount,
6266                               uint32_t                            stride,
6267                               Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6268
6269    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6270    void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                  copyBufferAddress,
6271                                      uint32_t                                             copyCount,
6272                                      uint32_t                                             stride,
6273                                      VULKAN_HPP_NAMESPACE::Image                          dstImage,
6274                                      VULKAN_HPP_NAMESPACE::ImageLayout                    dstImageLayout,
6275                                      const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources,
6276                                      Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6277#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6278    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6279    void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                                                          copyBufferAddress,
6280                                      uint32_t                                                                                     stride,
6281                                      VULKAN_HPP_NAMESPACE::Image                                                                  dstImage,
6282                                      VULKAN_HPP_NAMESPACE::ImageLayout                                                            dstImageLayout,
6283                                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources,
6284                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6285#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6286
6287    //=== VK_NV_memory_decompression ===
6288
6289    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6290    void decompressMemoryNV( uint32_t                                               decompressRegionCount,
6291                             const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions,
6292                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6293#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6294    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6295    void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions,
6296                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6297#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6298
6299    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6300    void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,
6301                                          VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,
6302                                          uint32_t                            stride,
6303                                          Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6304
6305    //=== VK_NV_device_generated_commands_compute ===
6306
6307    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6308    void updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6309                                         VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
6310                                         Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6311
6312    //=== VK_EXT_extended_dynamic_state3 ===
6313
6314    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6315    void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin,
6316                                         Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6317
6318    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6319    void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable,
6320                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6321
6322    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6323    void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode,
6324                            Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6325
6326    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6327    void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples,
6328                                     Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6329
6330    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6331    void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
6332                           const VULKAN_HPP_NAMESPACE::SampleMask *  pSampleMask,
6333                           Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6334#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6335    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6336    void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits                                        samples,
6337                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask,
6338                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6339#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6340
6341    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6342    void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable,
6343                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6344
6345    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6346    void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable,
6347                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6348
6349    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6350    void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable,
6351                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6352
6353    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6354    void setColorBlendEnableEXT( uint32_t                             firstAttachment,
6355                                 uint32_t                             attachmentCount,
6356                                 const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables,
6357                                 Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6358#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6359    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6360    void setColorBlendEnableEXT( uint32_t                                                                     firstAttachment,
6361                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables,
6362                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6363#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6364
6365    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6366    void setColorBlendEquationEXT( uint32_t                                            firstAttachment,
6367                                   uint32_t                                            attachmentCount,
6368                                   const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations,
6369                                   Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6370#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6371    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6372    void setColorBlendEquationEXT( uint32_t                                                                                    firstAttachment,
6373                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations,
6374                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6375#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6376
6377    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6378    void setColorWriteMaskEXT( uint32_t                                          firstAttachment,
6379                               uint32_t                                          attachmentCount,
6380                               const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks,
6381                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6382#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6383    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6384    void setColorWriteMaskEXT( uint32_t                                                                                  firstAttachment,
6385                               VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks,
6386                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6387#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6388
6389    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6390    void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6391
6392    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6393    void setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode,
6394                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6395
6396    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6397    void setExtraPrimitiveOverestimationSizeEXT( float              extraPrimitiveOverestimationSize,
6398                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6399
6400    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6401    void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable,
6402                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6403
6404    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6405    void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable,
6406                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6407
6408    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6409    void setColorBlendAdvancedEXT( uint32_t                                            firstAttachment,
6410                                   uint32_t                                            attachmentCount,
6411                                   const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced,
6412                                   Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6413#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6414    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6415    void setColorBlendAdvancedEXT( uint32_t                                                                                    firstAttachment,
6416                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced,
6417                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6418#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6419
6420    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6421    void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode,
6422                                    Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6423
6424    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6425    void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode,
6426                                      Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6427
6428    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6429    void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable,
6430                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6431
6432    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6433    void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne,
6434                                          Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6435
6436    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6437    void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable,
6438                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6439
6440    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6441    void setViewportSwizzleNV( uint32_t                                        firstViewport,
6442                               uint32_t                                        viewportCount,
6443                               const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles,
6444                               Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6445#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6446    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6447    void setViewportSwizzleNV( uint32_t                                                                                firstViewport,
6448                               VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles,
6449                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6450#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6451
6452    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6453    void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable,
6454                                     Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6455
6456    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6457    void setCoverageToColorLocationNV( uint32_t           coverageToColorLocation,
6458                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6459
6460    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6461    void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode,
6462                                      Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6463
6464    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6465    void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable,
6466                                             Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6467
6468    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6469    void setCoverageModulationTableNV( uint32_t           coverageModulationTableCount,
6470                                       const float *      pCoverageModulationTable,
6471                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6472#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6473    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6474    void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable,
6475                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6476#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6477
6478    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6479    void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable,
6480                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6481
6482    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6483    void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable,
6484                                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6485
6486    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6487    void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode,
6488                                     Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6489
6490    //=== VK_NV_optical_flow ===
6491
6492    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6493    void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
6494                               const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo,
6495                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6496#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6497    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6498    void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
6499                               const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo,
6500                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6501#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6502
6503    //=== VK_KHR_maintenance5 ===
6504
6505    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6506    void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6507                              VULKAN_HPP_NAMESPACE::DeviceSize offset,
6508                              VULKAN_HPP_NAMESPACE::DeviceSize size,
6509                              VULKAN_HPP_NAMESPACE::IndexType  indexType,
6510                              Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6511
6512    //=== VK_EXT_shader_object ===
6513
6514    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6515    void bindShadersEXT( uint32_t                                          stageCount,
6516                         const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits * pStages,
6517                         const VULKAN_HPP_NAMESPACE::ShaderEXT *           pShaders,
6518                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6519#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6520    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6521    void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages,
6522                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const &           shaders,
6523                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6524#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6525
6526    //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
6527
6528    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6529    void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask,
6530                                             Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6531
6532    //=== VK_KHR_maintenance6 ===
6533
6534    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6535    void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR * pBindDescriptorSetsInfo,
6536                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6537#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6538    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6539    void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR & bindDescriptorSetsInfo,
6540                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6541#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6542
6543    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6544    void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR * pPushConstantsInfo,
6545                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6546#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6547    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6548    void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR & pushConstantsInfo,
6549                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6550#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6551
6552    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6553    void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR * pPushDescriptorSetInfo,
6554                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6555#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6556    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6557    void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR & pushDescriptorSetInfo,
6558                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6559#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6560
6561    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6562    void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR * pPushDescriptorSetWithTemplateInfo,
6563                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6564#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6565    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6566    void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR & pushDescriptorSetWithTemplateInfo,
6567                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6568#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6569
6570    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6571    void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo,
6572                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6573#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6574    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6575    void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo,
6576                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6577#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6578
6579    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6580    void bindDescriptorBufferEmbeddedSamplers2EXT(
6581      const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo,
6582      Dispatch const & d                                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6583#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6584    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6585    void bindDescriptorBufferEmbeddedSamplers2EXT(
6586      const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo,
6587      Dispatch const & d                                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6588#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6589
6590    operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
6591    {
6592      return m_commandBuffer;
6593    }
6594
6595    explicit operator bool() const VULKAN_HPP_NOEXCEPT
6596    {
6597      return m_commandBuffer != VK_NULL_HANDLE;
6598    }
6599
6600    bool operator!() const VULKAN_HPP_NOEXCEPT
6601    {
6602      return m_commandBuffer == VK_NULL_HANDLE;
6603    }
6604
6605  private:
6606    VkCommandBuffer m_commandBuffer = {};
6607  };
6608
6609  template <>
6610  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
6611  {
6612    using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
6613  };
6614
6615  template <>
6616  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
6617  {
6618    using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
6619  };
6620
6621  template <>
6622  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
6623  {
6624    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6625  };
6626
6627  class DeviceMemory
6628  {
6629  public:
6630    using CType      = VkDeviceMemory;
6631    using NativeType = VkDeviceMemory;
6632
6633    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
6634    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6635      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
6636
6637  public:
6638    VULKAN_HPP_CONSTEXPR DeviceMemory() = default;
6639
6640    VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6641
6642    VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}
6643
6644#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6645    DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
6646    {
6647      m_deviceMemory = deviceMemory;
6648      return *this;
6649    }
6650#endif
6651
6652    DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6653    {
6654      m_deviceMemory = {};
6655      return *this;
6656    }
6657
6658#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6659    auto operator<=>( DeviceMemory const & ) const = default;
6660#else
6661    bool                                 operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
6662    {
6663      return m_deviceMemory == rhs.m_deviceMemory;
6664    }
6665
6666    bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
6667    {
6668      return m_deviceMemory != rhs.m_deviceMemory;
6669    }
6670
6671    bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
6672    {
6673      return m_deviceMemory < rhs.m_deviceMemory;
6674    }
6675#endif
6676
6677    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
6678    {
6679      return m_deviceMemory;
6680    }
6681
6682    explicit operator bool() const VULKAN_HPP_NOEXCEPT
6683    {
6684      return m_deviceMemory != VK_NULL_HANDLE;
6685    }
6686
6687    bool operator!() const VULKAN_HPP_NOEXCEPT
6688    {
6689      return m_deviceMemory == VK_NULL_HANDLE;
6690    }
6691
6692  private:
6693    VkDeviceMemory m_deviceMemory = {};
6694  };
6695
6696  template <>
6697  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
6698  {
6699    using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
6700  };
6701
6702  template <>
6703  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
6704  {
6705    using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
6706  };
6707
6708  template <>
6709  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
6710  {
6711    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6712  };
6713
6714  class VideoSessionKHR
6715  {
6716  public:
6717    using CType      = VkVideoSessionKHR;
6718    using NativeType = VkVideoSessionKHR;
6719
6720    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
6721    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6722      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6723
6724  public:
6725    VULKAN_HPP_CONSTEXPR VideoSessionKHR() = default;
6726
6727    VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6728
6729    VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}
6730
6731#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6732    VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
6733    {
6734      m_videoSessionKHR = videoSessionKHR;
6735      return *this;
6736    }
6737#endif
6738
6739    VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6740    {
6741      m_videoSessionKHR = {};
6742      return *this;
6743    }
6744
6745#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6746    auto operator<=>( VideoSessionKHR const & ) const = default;
6747#else
6748    bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6749    {
6750      return m_videoSessionKHR == rhs.m_videoSessionKHR;
6751    }
6752
6753    bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6754    {
6755      return m_videoSessionKHR != rhs.m_videoSessionKHR;
6756    }
6757
6758    bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6759    {
6760      return m_videoSessionKHR < rhs.m_videoSessionKHR;
6761    }
6762#endif
6763
6764    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
6765    {
6766      return m_videoSessionKHR;
6767    }
6768
6769    explicit operator bool() const VULKAN_HPP_NOEXCEPT
6770    {
6771      return m_videoSessionKHR != VK_NULL_HANDLE;
6772    }
6773
6774    bool operator!() const VULKAN_HPP_NOEXCEPT
6775    {
6776      return m_videoSessionKHR == VK_NULL_HANDLE;
6777    }
6778
6779  private:
6780    VkVideoSessionKHR m_videoSessionKHR = {};
6781  };
6782
6783  template <>
6784  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
6785  {
6786    using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
6787  };
6788
6789  template <>
6790  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
6791  {
6792    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6793  };
6794
6795  class DeferredOperationKHR
6796  {
6797  public:
6798    using CType      = VkDeferredOperationKHR;
6799    using NativeType = VkDeferredOperationKHR;
6800
6801    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
6802    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6803      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6804
6805  public:
6806    VULKAN_HPP_CONSTEXPR DeferredOperationKHR() = default;
6807
6808    VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6809
6810    VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
6811      : m_deferredOperationKHR( deferredOperationKHR )
6812    {
6813    }
6814
6815#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6816    DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
6817    {
6818      m_deferredOperationKHR = deferredOperationKHR;
6819      return *this;
6820    }
6821#endif
6822
6823    DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6824    {
6825      m_deferredOperationKHR = {};
6826      return *this;
6827    }
6828
6829#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6830    auto operator<=>( DeferredOperationKHR const & ) const = default;
6831#else
6832    bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6833    {
6834      return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
6835    }
6836
6837    bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6838    {
6839      return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
6840    }
6841
6842    bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6843    {
6844      return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
6845    }
6846#endif
6847
6848    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
6849    {
6850      return m_deferredOperationKHR;
6851    }
6852
6853    explicit operator bool() const VULKAN_HPP_NOEXCEPT
6854    {
6855      return m_deferredOperationKHR != VK_NULL_HANDLE;
6856    }
6857
6858    bool operator!() const VULKAN_HPP_NOEXCEPT
6859    {
6860      return m_deferredOperationKHR == VK_NULL_HANDLE;
6861    }
6862
6863  private:
6864    VkDeferredOperationKHR m_deferredOperationKHR = {};
6865  };
6866
6867  template <>
6868  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
6869  {
6870    using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
6871  };
6872
6873  template <>
6874  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
6875  {
6876    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6877  };
6878
6879#if defined( VK_USE_PLATFORM_FUCHSIA )
6880  class BufferCollectionFUCHSIA
6881  {
6882  public:
6883    using CType      = VkBufferCollectionFUCHSIA;
6884    using NativeType = VkBufferCollectionFUCHSIA;
6885
6886    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
6887    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6888      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
6889
6890  public:
6891    VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA() = default;
6892
6893    VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6894
6895    VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
6896      : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
6897    {
6898    }
6899
6900#  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6901    BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
6902    {
6903      m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
6904      return *this;
6905    }
6906#  endif
6907
6908    BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6909    {
6910      m_bufferCollectionFUCHSIA = {};
6911      return *this;
6912    }
6913
6914#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6915    auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;
6916#  else
6917    bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6918    {
6919      return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
6920    }
6921
6922    bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6923    {
6924      return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
6925    }
6926
6927    bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6928    {
6929      return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
6930    }
6931#  endif
6932
6933    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
6934    {
6935      return m_bufferCollectionFUCHSIA;
6936    }
6937
6938    explicit operator bool() const VULKAN_HPP_NOEXCEPT
6939    {
6940      return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
6941    }
6942
6943    bool operator!() const VULKAN_HPP_NOEXCEPT
6944    {
6945      return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
6946    }
6947
6948  private:
6949    VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
6950  };
6951
6952  template <>
6953  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>
6954  {
6955    using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
6956  };
6957
6958  template <>
6959  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
6960  {
6961    using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
6962  };
6963
6964  template <>
6965  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
6966  {
6967    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6968  };
6969#endif /*VK_USE_PLATFORM_FUCHSIA*/
6970
6971  class BufferView
6972  {
6973  public:
6974    using CType      = VkBufferView;
6975    using NativeType = VkBufferView;
6976
6977    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
6978    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6979      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
6980
6981  public:
6982    VULKAN_HPP_CONSTEXPR BufferView() = default;
6983
6984    VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6985
6986    VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}
6987
6988#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6989    BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
6990    {
6991      m_bufferView = bufferView;
6992      return *this;
6993    }
6994#endif
6995
6996    BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6997    {
6998      m_bufferView = {};
6999      return *this;
7000    }
7001
7002#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7003    auto operator<=>( BufferView const & ) const = default;
7004#else
7005    bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7006    {
7007      return m_bufferView == rhs.m_bufferView;
7008    }
7009
7010    bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7011    {
7012      return m_bufferView != rhs.m_bufferView;
7013    }
7014
7015    bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7016    {
7017      return m_bufferView < rhs.m_bufferView;
7018    }
7019#endif
7020
7021    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
7022    {
7023      return m_bufferView;
7024    }
7025
7026    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7027    {
7028      return m_bufferView != VK_NULL_HANDLE;
7029    }
7030
7031    bool operator!() const VULKAN_HPP_NOEXCEPT
7032    {
7033      return m_bufferView == VK_NULL_HANDLE;
7034    }
7035
7036  private:
7037    VkBufferView m_bufferView = {};
7038  };
7039
7040  template <>
7041  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
7042  {
7043    using Type = VULKAN_HPP_NAMESPACE::BufferView;
7044  };
7045
7046  template <>
7047  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
7048  {
7049    using Type = VULKAN_HPP_NAMESPACE::BufferView;
7050  };
7051
7052  template <>
7053  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
7054  {
7055    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7056  };
7057
7058  class CommandPool
7059  {
7060  public:
7061    using CType      = VkCommandPool;
7062    using NativeType = VkCommandPool;
7063
7064    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
7065    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7066      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
7067
7068  public:
7069    VULKAN_HPP_CONSTEXPR CommandPool() = default;
7070
7071    VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7072
7073    VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}
7074
7075#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7076    CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
7077    {
7078      m_commandPool = commandPool;
7079      return *this;
7080    }
7081#endif
7082
7083    CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7084    {
7085      m_commandPool = {};
7086      return *this;
7087    }
7088
7089#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7090    auto operator<=>( CommandPool const & ) const = default;
7091#else
7092    bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7093    {
7094      return m_commandPool == rhs.m_commandPool;
7095    }
7096
7097    bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7098    {
7099      return m_commandPool != rhs.m_commandPool;
7100    }
7101
7102    bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7103    {
7104      return m_commandPool < rhs.m_commandPool;
7105    }
7106#endif
7107
7108    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
7109    {
7110      return m_commandPool;
7111    }
7112
7113    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7114    {
7115      return m_commandPool != VK_NULL_HANDLE;
7116    }
7117
7118    bool operator!() const VULKAN_HPP_NOEXCEPT
7119    {
7120      return m_commandPool == VK_NULL_HANDLE;
7121    }
7122
7123  private:
7124    VkCommandPool m_commandPool = {};
7125  };
7126
7127  template <>
7128  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
7129  {
7130    using Type = VULKAN_HPP_NAMESPACE::CommandPool;
7131  };
7132
7133  template <>
7134  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
7135  {
7136    using Type = VULKAN_HPP_NAMESPACE::CommandPool;
7137  };
7138
7139  template <>
7140  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
7141  {
7142    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7143  };
7144
7145  class PipelineCache
7146  {
7147  public:
7148    using CType      = VkPipelineCache;
7149    using NativeType = VkPipelineCache;
7150
7151    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
7152    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7153      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
7154
7155  public:
7156    VULKAN_HPP_CONSTEXPR PipelineCache() = default;
7157
7158    VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7159
7160    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}
7161
7162#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7163    PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
7164    {
7165      m_pipelineCache = pipelineCache;
7166      return *this;
7167    }
7168#endif
7169
7170    PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7171    {
7172      m_pipelineCache = {};
7173      return *this;
7174    }
7175
7176#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7177    auto operator<=>( PipelineCache const & ) const = default;
7178#else
7179    bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7180    {
7181      return m_pipelineCache == rhs.m_pipelineCache;
7182    }
7183
7184    bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7185    {
7186      return m_pipelineCache != rhs.m_pipelineCache;
7187    }
7188
7189    bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7190    {
7191      return m_pipelineCache < rhs.m_pipelineCache;
7192    }
7193#endif
7194
7195    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
7196    {
7197      return m_pipelineCache;
7198    }
7199
7200    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7201    {
7202      return m_pipelineCache != VK_NULL_HANDLE;
7203    }
7204
7205    bool operator!() const VULKAN_HPP_NOEXCEPT
7206    {
7207      return m_pipelineCache == VK_NULL_HANDLE;
7208    }
7209
7210  private:
7211    VkPipelineCache m_pipelineCache = {};
7212  };
7213
7214  template <>
7215  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
7216  {
7217    using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
7218  };
7219
7220  template <>
7221  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
7222  {
7223    using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
7224  };
7225
7226  template <>
7227  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
7228  {
7229    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7230  };
7231
7232  class CuFunctionNVX
7233  {
7234  public:
7235    using CType      = VkCuFunctionNVX;
7236    using NativeType = VkCuFunctionNVX;
7237
7238    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
7239    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7240      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
7241
7242  public:
7243    VULKAN_HPP_CONSTEXPR CuFunctionNVX() = default;
7244
7245    VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7246
7247    VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}
7248
7249#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7250    CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
7251    {
7252      m_cuFunctionNVX = cuFunctionNVX;
7253      return *this;
7254    }
7255#endif
7256
7257    CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7258    {
7259      m_cuFunctionNVX = {};
7260      return *this;
7261    }
7262
7263#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7264    auto operator<=>( CuFunctionNVX const & ) const = default;
7265#else
7266    bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7267    {
7268      return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
7269    }
7270
7271    bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7272    {
7273      return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
7274    }
7275
7276    bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7277    {
7278      return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
7279    }
7280#endif
7281
7282    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
7283    {
7284      return m_cuFunctionNVX;
7285    }
7286
7287    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7288    {
7289      return m_cuFunctionNVX != VK_NULL_HANDLE;
7290    }
7291
7292    bool operator!() const VULKAN_HPP_NOEXCEPT
7293    {
7294      return m_cuFunctionNVX == VK_NULL_HANDLE;
7295    }
7296
7297  private:
7298    VkCuFunctionNVX m_cuFunctionNVX = {};
7299  };
7300
7301  template <>
7302  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
7303  {
7304    using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
7305  };
7306
7307  template <>
7308  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
7309  {
7310    using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
7311  };
7312
7313  template <>
7314  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
7315  {
7316    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7317  };
7318
7319  class CuModuleNVX
7320  {
7321  public:
7322    using CType      = VkCuModuleNVX;
7323    using NativeType = VkCuModuleNVX;
7324
7325    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
7326    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7327      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
7328
7329  public:
7330    VULKAN_HPP_CONSTEXPR CuModuleNVX() = default;
7331
7332    VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7333
7334    VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}
7335
7336#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7337    CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
7338    {
7339      m_cuModuleNVX = cuModuleNVX;
7340      return *this;
7341    }
7342#endif
7343
7344    CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7345    {
7346      m_cuModuleNVX = {};
7347      return *this;
7348    }
7349
7350#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7351    auto operator<=>( CuModuleNVX const & ) const = default;
7352#else
7353    bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7354    {
7355      return m_cuModuleNVX == rhs.m_cuModuleNVX;
7356    }
7357
7358    bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7359    {
7360      return m_cuModuleNVX != rhs.m_cuModuleNVX;
7361    }
7362
7363    bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7364    {
7365      return m_cuModuleNVX < rhs.m_cuModuleNVX;
7366    }
7367#endif
7368
7369    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
7370    {
7371      return m_cuModuleNVX;
7372    }
7373
7374    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7375    {
7376      return m_cuModuleNVX != VK_NULL_HANDLE;
7377    }
7378
7379    bool operator!() const VULKAN_HPP_NOEXCEPT
7380    {
7381      return m_cuModuleNVX == VK_NULL_HANDLE;
7382    }
7383
7384  private:
7385    VkCuModuleNVX m_cuModuleNVX = {};
7386  };
7387
7388  template <>
7389  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
7390  {
7391    using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
7392  };
7393
7394  template <>
7395  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
7396  {
7397    using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
7398  };
7399
7400  template <>
7401  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
7402  {
7403    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7404  };
7405
7406#if defined( VK_ENABLE_BETA_EXTENSIONS )
7407  class CudaFunctionNV
7408  {
7409  public:
7410    using CType      = VkCudaFunctionNV;
7411    using NativeType = VkCudaFunctionNV;
7412
7413    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV;
7414    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7415      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV;
7416
7417  public:
7418    VULKAN_HPP_CONSTEXPR CudaFunctionNV() = default;
7419
7420    VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7421
7422    VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {}
7423
7424#  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7425    CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT
7426    {
7427      m_cudaFunctionNV = cudaFunctionNV;
7428      return *this;
7429    }
7430#  endif
7431
7432    CudaFunctionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7433    {
7434      m_cudaFunctionNV = {};
7435      return *this;
7436    }
7437
7438#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7439    auto operator<=>( CudaFunctionNV const & ) const = default;
7440#  else
7441    bool operator==( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7442    {
7443      return m_cudaFunctionNV == rhs.m_cudaFunctionNV;
7444    }
7445
7446    bool operator!=( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7447    {
7448      return m_cudaFunctionNV != rhs.m_cudaFunctionNV;
7449    }
7450
7451    bool operator<( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7452    {
7453      return m_cudaFunctionNV < rhs.m_cudaFunctionNV;
7454    }
7455#  endif
7456
7457    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT
7458    {
7459      return m_cudaFunctionNV;
7460    }
7461
7462    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7463    {
7464      return m_cudaFunctionNV != VK_NULL_HANDLE;
7465    }
7466
7467    bool operator!() const VULKAN_HPP_NOEXCEPT
7468    {
7469      return m_cudaFunctionNV == VK_NULL_HANDLE;
7470    }
7471
7472  private:
7473    VkCudaFunctionNV m_cudaFunctionNV = {};
7474  };
7475
7476  template <>
7477  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV>
7478  {
7479    using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
7480  };
7481
7482  template <>
7483  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV>
7484  {
7485    using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
7486  };
7487
7488  template <>
7489  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>
7490  {
7491    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7492  };
7493#endif /*VK_ENABLE_BETA_EXTENSIONS*/
7494
7495#if defined( VK_ENABLE_BETA_EXTENSIONS )
7496  class CudaModuleNV
7497  {
7498  public:
7499    using CType      = VkCudaModuleNV;
7500    using NativeType = VkCudaModuleNV;
7501
7502    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV;
7503    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7504      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV;
7505
7506  public:
7507    VULKAN_HPP_CONSTEXPR CudaModuleNV() = default;
7508
7509    VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7510
7511    VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {}
7512
7513#  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7514    CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT
7515    {
7516      m_cudaModuleNV = cudaModuleNV;
7517      return *this;
7518    }
7519#  endif
7520
7521    CudaModuleNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7522    {
7523      m_cudaModuleNV = {};
7524      return *this;
7525    }
7526
7527#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7528    auto operator<=>( CudaModuleNV const & ) const = default;
7529#  else
7530    bool operator==( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7531    {
7532      return m_cudaModuleNV == rhs.m_cudaModuleNV;
7533    }
7534
7535    bool operator!=( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7536    {
7537      return m_cudaModuleNV != rhs.m_cudaModuleNV;
7538    }
7539
7540    bool operator<( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7541    {
7542      return m_cudaModuleNV < rhs.m_cudaModuleNV;
7543    }
7544#  endif
7545
7546    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT
7547    {
7548      return m_cudaModuleNV;
7549    }
7550
7551    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7552    {
7553      return m_cudaModuleNV != VK_NULL_HANDLE;
7554    }
7555
7556    bool operator!() const VULKAN_HPP_NOEXCEPT
7557    {
7558      return m_cudaModuleNV == VK_NULL_HANDLE;
7559    }
7560
7561  private:
7562    VkCudaModuleNV m_cudaModuleNV = {};
7563  };
7564
7565  template <>
7566  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV>
7567  {
7568    using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
7569  };
7570
7571  template <>
7572  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV>
7573  {
7574    using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
7575  };
7576
7577  template <>
7578  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaModuleNV>
7579  {
7580    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7581  };
7582#endif /*VK_ENABLE_BETA_EXTENSIONS*/
7583
7584  class DescriptorPool
7585  {
7586  public:
7587    using CType      = VkDescriptorPool;
7588    using NativeType = VkDescriptorPool;
7589
7590    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
7591    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7592      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
7593
7594  public:
7595    VULKAN_HPP_CONSTEXPR DescriptorPool() = default;
7596
7597    VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7598
7599    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}
7600
7601#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7602    DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
7603    {
7604      m_descriptorPool = descriptorPool;
7605      return *this;
7606    }
7607#endif
7608
7609    DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7610    {
7611      m_descriptorPool = {};
7612      return *this;
7613    }
7614
7615#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7616    auto operator<=>( DescriptorPool const & ) const = default;
7617#else
7618    bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7619    {
7620      return m_descriptorPool == rhs.m_descriptorPool;
7621    }
7622
7623    bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7624    {
7625      return m_descriptorPool != rhs.m_descriptorPool;
7626    }
7627
7628    bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7629    {
7630      return m_descriptorPool < rhs.m_descriptorPool;
7631    }
7632#endif
7633
7634    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
7635    {
7636      return m_descriptorPool;
7637    }
7638
7639    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7640    {
7641      return m_descriptorPool != VK_NULL_HANDLE;
7642    }
7643
7644    bool operator!() const VULKAN_HPP_NOEXCEPT
7645    {
7646      return m_descriptorPool == VK_NULL_HANDLE;
7647    }
7648
7649  private:
7650    VkDescriptorPool m_descriptorPool = {};
7651  };
7652
7653  template <>
7654  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
7655  {
7656    using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
7657  };
7658
7659  template <>
7660  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
7661  {
7662    using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
7663  };
7664
7665  template <>
7666  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
7667  {
7668    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7669  };
7670
7671  class DescriptorSetLayout
7672  {
7673  public:
7674    using CType      = VkDescriptorSetLayout;
7675    using NativeType = VkDescriptorSetLayout;
7676
7677    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
7678    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7679      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
7680
7681  public:
7682    VULKAN_HPP_CONSTEXPR DescriptorSetLayout() = default;
7683
7684    VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7685
7686    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
7687      : m_descriptorSetLayout( descriptorSetLayout )
7688    {
7689    }
7690
7691#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7692    DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
7693    {
7694      m_descriptorSetLayout = descriptorSetLayout;
7695      return *this;
7696    }
7697#endif
7698
7699    DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7700    {
7701      m_descriptorSetLayout = {};
7702      return *this;
7703    }
7704
7705#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7706    auto operator<=>( DescriptorSetLayout const & ) const = default;
7707#else
7708    bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
7709    {
7710      return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
7711    }
7712
7713    bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
7714    {
7715      return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
7716    }
7717
7718    bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
7719    {
7720      return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
7721    }
7722#endif
7723
7724    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
7725    {
7726      return m_descriptorSetLayout;
7727    }
7728
7729    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7730    {
7731      return m_descriptorSetLayout != VK_NULL_HANDLE;
7732    }
7733
7734    bool operator!() const VULKAN_HPP_NOEXCEPT
7735    {
7736      return m_descriptorSetLayout == VK_NULL_HANDLE;
7737    }
7738
7739  private:
7740    VkDescriptorSetLayout m_descriptorSetLayout = {};
7741  };
7742
7743  template <>
7744  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
7745  {
7746    using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
7747  };
7748
7749  template <>
7750  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
7751  {
7752    using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
7753  };
7754
7755  template <>
7756  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
7757  {
7758    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7759  };
7760
7761  class Framebuffer
7762  {
7763  public:
7764    using CType      = VkFramebuffer;
7765    using NativeType = VkFramebuffer;
7766
7767    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
7768    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7769      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
7770
7771  public:
7772    VULKAN_HPP_CONSTEXPR Framebuffer() = default;
7773
7774    VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7775
7776    VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {}
7777
7778#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7779    Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
7780    {
7781      m_framebuffer = framebuffer;
7782      return *this;
7783    }
7784#endif
7785
7786    Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7787    {
7788      m_framebuffer = {};
7789      return *this;
7790    }
7791
7792#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7793    auto operator<=>( Framebuffer const & ) const = default;
7794#else
7795    bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
7796    {
7797      return m_framebuffer == rhs.m_framebuffer;
7798    }
7799
7800    bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
7801    {
7802      return m_framebuffer != rhs.m_framebuffer;
7803    }
7804
7805    bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
7806    {
7807      return m_framebuffer < rhs.m_framebuffer;
7808    }
7809#endif
7810
7811    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
7812    {
7813      return m_framebuffer;
7814    }
7815
7816    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7817    {
7818      return m_framebuffer != VK_NULL_HANDLE;
7819    }
7820
7821    bool operator!() const VULKAN_HPP_NOEXCEPT
7822    {
7823      return m_framebuffer == VK_NULL_HANDLE;
7824    }
7825
7826  private:
7827    VkFramebuffer m_framebuffer = {};
7828  };
7829
7830  template <>
7831  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
7832  {
7833    using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
7834  };
7835
7836  template <>
7837  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
7838  {
7839    using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
7840  };
7841
7842  template <>
7843  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
7844  {
7845    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7846  };
7847
7848  class IndirectCommandsLayoutNV
7849  {
7850  public:
7851    using CType      = VkIndirectCommandsLayoutNV;
7852    using NativeType = VkIndirectCommandsLayoutNV;
7853
7854    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
7855    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7856      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7857
7858  public:
7859    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default;
7860
7861    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7862
7863    VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
7864      : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
7865    {
7866    }
7867
7868#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7869    IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
7870    {
7871      m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
7872      return *this;
7873    }
7874#endif
7875
7876    IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7877    {
7878      m_indirectCommandsLayoutNV = {};
7879      return *this;
7880    }
7881
7882#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7883    auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
7884#else
7885    bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7886    {
7887      return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
7888    }
7889
7890    bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7891    {
7892      return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
7893    }
7894
7895    bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7896    {
7897      return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
7898    }
7899#endif
7900
7901    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
7902    {
7903      return m_indirectCommandsLayoutNV;
7904    }
7905
7906    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7907    {
7908      return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
7909    }
7910
7911    bool operator!() const VULKAN_HPP_NOEXCEPT
7912    {
7913      return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
7914    }
7915
7916  private:
7917    VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
7918  };
7919
7920  template <>
7921  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
7922  {
7923    using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
7924  };
7925
7926  template <>
7927  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
7928  {
7929    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7930  };
7931
7932  class PrivateDataSlot
7933  {
7934  public:
7935    using CType      = VkPrivateDataSlot;
7936    using NativeType = VkPrivateDataSlot;
7937
7938    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;
7939    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7940      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7941
7942  public:
7943    VULKAN_HPP_CONSTEXPR PrivateDataSlot() = default;
7944
7945    VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7946
7947    VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}
7948
7949#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7950    PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
7951    {
7952      m_privateDataSlot = privateDataSlot;
7953      return *this;
7954    }
7955#endif
7956
7957    PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7958    {
7959      m_privateDataSlot = {};
7960      return *this;
7961    }
7962
7963#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7964    auto operator<=>( PrivateDataSlot const & ) const = default;
7965#else
7966    bool operator==( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
7967    {
7968      return m_privateDataSlot == rhs.m_privateDataSlot;
7969    }
7970
7971    bool operator!=( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
7972    {
7973      return m_privateDataSlot != rhs.m_privateDataSlot;
7974    }
7975
7976    bool operator<( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
7977    {
7978      return m_privateDataSlot < rhs.m_privateDataSlot;
7979    }
7980#endif
7981
7982    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
7983    {
7984      return m_privateDataSlot;
7985    }
7986
7987    explicit operator bool() const VULKAN_HPP_NOEXCEPT
7988    {
7989      return m_privateDataSlot != VK_NULL_HANDLE;
7990    }
7991
7992    bool operator!() const VULKAN_HPP_NOEXCEPT
7993    {
7994      return m_privateDataSlot == VK_NULL_HANDLE;
7995    }
7996
7997  private:
7998    VkPrivateDataSlot m_privateDataSlot = {};
7999  };
8000
8001  template <>
8002  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>
8003  {
8004    using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;
8005  };
8006
8007  template <>
8008  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
8009  {
8010    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8011  };
8012
8013  using PrivateDataSlotEXT = PrivateDataSlot;
8014
8015  class RenderPass
8016  {
8017  public:
8018    using CType      = VkRenderPass;
8019    using NativeType = VkRenderPass;
8020
8021    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
8022    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8023      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
8024
8025  public:
8026    VULKAN_HPP_CONSTEXPR RenderPass() = default;
8027
8028    VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8029
8030    VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}
8031
8032#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8033    RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
8034    {
8035      m_renderPass = renderPass;
8036      return *this;
8037    }
8038#endif
8039
8040    RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8041    {
8042      m_renderPass = {};
8043      return *this;
8044    }
8045
8046#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8047    auto operator<=>( RenderPass const & ) const = default;
8048#else
8049    bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8050    {
8051      return m_renderPass == rhs.m_renderPass;
8052    }
8053
8054    bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8055    {
8056      return m_renderPass != rhs.m_renderPass;
8057    }
8058
8059    bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8060    {
8061      return m_renderPass < rhs.m_renderPass;
8062    }
8063#endif
8064
8065    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
8066    {
8067      return m_renderPass;
8068    }
8069
8070    explicit operator bool() const VULKAN_HPP_NOEXCEPT
8071    {
8072      return m_renderPass != VK_NULL_HANDLE;
8073    }
8074
8075    bool operator!() const VULKAN_HPP_NOEXCEPT
8076    {
8077      return m_renderPass == VK_NULL_HANDLE;
8078    }
8079
8080  private:
8081    VkRenderPass m_renderPass = {};
8082  };
8083
8084  template <>
8085  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
8086  {
8087    using Type = VULKAN_HPP_NAMESPACE::RenderPass;
8088  };
8089
8090  template <>
8091  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
8092  {
8093    using Type = VULKAN_HPP_NAMESPACE::RenderPass;
8094  };
8095
8096  template <>
8097  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
8098  {
8099    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8100  };
8101
8102  class Sampler
8103  {
8104  public:
8105    using CType      = VkSampler;
8106    using NativeType = VkSampler;
8107
8108    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
8109    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8110      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
8111
8112  public:
8113    VULKAN_HPP_CONSTEXPR Sampler() = default;
8114
8115    VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8116
8117    VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
8118
8119#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8120    Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
8121    {
8122      m_sampler = sampler;
8123      return *this;
8124    }
8125#endif
8126
8127    Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8128    {
8129      m_sampler = {};
8130      return *this;
8131    }
8132
8133#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8134    auto operator<=>( Sampler const & ) const = default;
8135#else
8136    bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8137    {
8138      return m_sampler == rhs.m_sampler;
8139    }
8140
8141    bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8142    {
8143      return m_sampler != rhs.m_sampler;
8144    }
8145
8146    bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8147    {
8148      return m_sampler < rhs.m_sampler;
8149    }
8150#endif
8151
8152    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
8153    {
8154      return m_sampler;
8155    }
8156
8157    explicit operator bool() const VULKAN_HPP_NOEXCEPT
8158    {
8159      return m_sampler != VK_NULL_HANDLE;
8160    }
8161
8162    bool operator!() const VULKAN_HPP_NOEXCEPT
8163    {
8164      return m_sampler == VK_NULL_HANDLE;
8165    }
8166
8167  private:
8168    VkSampler m_sampler = {};
8169  };
8170
8171  template <>
8172  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
8173  {
8174    using Type = VULKAN_HPP_NAMESPACE::Sampler;
8175  };
8176
8177  template <>
8178  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
8179  {
8180    using Type = VULKAN_HPP_NAMESPACE::Sampler;
8181  };
8182
8183  template <>
8184  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
8185  {
8186    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8187  };
8188
8189  class SamplerYcbcrConversion
8190  {
8191  public:
8192    using CType      = VkSamplerYcbcrConversion;
8193    using NativeType = VkSamplerYcbcrConversion;
8194
8195    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
8196    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8197      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
8198
8199  public:
8200    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;
8201
8202    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8203
8204    VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
8205      : m_samplerYcbcrConversion( samplerYcbcrConversion )
8206    {
8207    }
8208
8209#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8210    SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
8211    {
8212      m_samplerYcbcrConversion = samplerYcbcrConversion;
8213      return *this;
8214    }
8215#endif
8216
8217    SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8218    {
8219      m_samplerYcbcrConversion = {};
8220      return *this;
8221    }
8222
8223#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8224    auto operator<=>( SamplerYcbcrConversion const & ) const = default;
8225#else
8226    bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
8227    {
8228      return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
8229    }
8230
8231    bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
8232    {
8233      return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
8234    }
8235
8236    bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
8237    {
8238      return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
8239    }
8240#endif
8241
8242    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
8243    {
8244      return m_samplerYcbcrConversion;
8245    }
8246
8247    explicit operator bool() const VULKAN_HPP_NOEXCEPT
8248    {
8249      return m_samplerYcbcrConversion != VK_NULL_HANDLE;
8250    }
8251
8252    bool operator!() const VULKAN_HPP_NOEXCEPT
8253    {
8254      return m_samplerYcbcrConversion == VK_NULL_HANDLE;
8255    }
8256
8257  private:
8258    VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
8259  };
8260
8261  template <>
8262  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
8263  {
8264    using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
8265  };
8266
8267  template <>
8268  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
8269  {
8270    using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
8271  };
8272
8273  template <>
8274  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
8275  {
8276    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8277  };
8278
8279  using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
8280
8281  class ShaderModule
8282  {
8283  public:
8284    using CType      = VkShaderModule;
8285    using NativeType = VkShaderModule;
8286
8287    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
8288    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8289      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
8290
8291  public:
8292    VULKAN_HPP_CONSTEXPR ShaderModule() = default;
8293
8294    VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8295
8296    VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}
8297
8298#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8299    ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
8300    {
8301      m_shaderModule = shaderModule;
8302      return *this;
8303    }
8304#endif
8305
8306    ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8307    {
8308      m_shaderModule = {};
8309      return *this;
8310    }
8311
8312#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8313    auto operator<=>( ShaderModule const & ) const = default;
8314#else
8315    bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8316    {
8317      return m_shaderModule == rhs.m_shaderModule;
8318    }
8319
8320    bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8321    {
8322      return m_shaderModule != rhs.m_shaderModule;
8323    }
8324
8325    bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8326    {
8327      return m_shaderModule < rhs.m_shaderModule;
8328    }
8329#endif
8330
8331    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
8332    {
8333      return m_shaderModule;
8334    }
8335
8336    explicit operator bool() const VULKAN_HPP_NOEXCEPT
8337    {
8338      return m_shaderModule != VK_NULL_HANDLE;
8339    }
8340
8341    bool operator!() const VULKAN_HPP_NOEXCEPT
8342    {
8343      return m_shaderModule == VK_NULL_HANDLE;
8344    }
8345
8346  private:
8347    VkShaderModule m_shaderModule = {};
8348  };
8349
8350  template <>
8351  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
8352  {
8353    using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
8354  };
8355
8356  template <>
8357  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
8358  {
8359    using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
8360  };
8361
8362  template <>
8363  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
8364  {
8365    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8366  };
8367
8368  class ValidationCacheEXT
8369  {
8370  public:
8371    using CType      = VkValidationCacheEXT;
8372    using NativeType = VkValidationCacheEXT;
8373
8374    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
8375    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8376      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
8377
8378  public:
8379    VULKAN_HPP_CONSTEXPR ValidationCacheEXT() = default;
8380
8381    VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8382
8383    VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )
8384    {
8385    }
8386
8387#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8388    ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
8389    {
8390      m_validationCacheEXT = validationCacheEXT;
8391      return *this;
8392    }
8393#endif
8394
8395    ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8396    {
8397      m_validationCacheEXT = {};
8398      return *this;
8399    }
8400
8401#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8402    auto operator<=>( ValidationCacheEXT const & ) const = default;
8403#else
8404    bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
8405    {
8406      return m_validationCacheEXT == rhs.m_validationCacheEXT;
8407    }
8408
8409    bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
8410    {
8411      return m_validationCacheEXT != rhs.m_validationCacheEXT;
8412    }
8413
8414    bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
8415    {
8416      return m_validationCacheEXT < rhs.m_validationCacheEXT;
8417    }
8418#endif
8419
8420    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
8421    {
8422      return m_validationCacheEXT;
8423    }
8424
8425    explicit operator bool() const VULKAN_HPP_NOEXCEPT
8426    {
8427      return m_validationCacheEXT != VK_NULL_HANDLE;
8428    }
8429
8430    bool operator!() const VULKAN_HPP_NOEXCEPT
8431    {
8432      return m_validationCacheEXT == VK_NULL_HANDLE;
8433    }
8434
8435  private:
8436    VkValidationCacheEXT m_validationCacheEXT = {};
8437  };
8438
8439  template <>
8440  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
8441  {
8442    using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
8443  };
8444
8445  template <>
8446  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
8447  {
8448    using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
8449  };
8450
8451  template <>
8452  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
8453  {
8454    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8455  };
8456
8457  class VideoSessionParametersKHR
8458  {
8459  public:
8460    using CType      = VkVideoSessionParametersKHR;
8461    using NativeType = VkVideoSessionParametersKHR;
8462
8463    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
8464    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8465      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
8466
8467  public:
8468    VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;
8469
8470    VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8471
8472    VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
8473      : m_videoSessionParametersKHR( videoSessionParametersKHR )
8474    {
8475    }
8476
8477#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8478    VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
8479    {
8480      m_videoSessionParametersKHR = videoSessionParametersKHR;
8481      return *this;
8482    }
8483#endif
8484
8485    VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8486    {
8487      m_videoSessionParametersKHR = {};
8488      return *this;
8489    }
8490
8491#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8492    auto operator<=>( VideoSessionParametersKHR const & ) const = default;
8493#else
8494    bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
8495    {
8496      return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
8497    }
8498
8499    bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
8500    {
8501      return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
8502    }
8503
8504    bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
8505    {
8506      return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
8507    }
8508#endif
8509
8510    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
8511    {
8512      return m_videoSessionParametersKHR;
8513    }
8514
8515    explicit operator bool() const VULKAN_HPP_NOEXCEPT
8516    {
8517      return m_videoSessionParametersKHR != VK_NULL_HANDLE;
8518    }
8519
8520    bool operator!() const VULKAN_HPP_NOEXCEPT
8521    {
8522      return m_videoSessionParametersKHR == VK_NULL_HANDLE;
8523    }
8524
8525  private:
8526    VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
8527  };
8528
8529  template <>
8530  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
8531  {
8532    using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
8533  };
8534
8535  template <>
8536  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
8537  {
8538    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8539  };
8540
8541  class Queue
8542  {
8543  public:
8544    using CType      = VkQueue;
8545    using NativeType = VkQueue;
8546
8547    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
8548    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8549      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
8550
8551  public:
8552    VULKAN_HPP_CONSTEXPR Queue() = default;
8553
8554    VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8555
8556    Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
8557
8558    Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
8559    {
8560      m_queue = queue;
8561      return *this;
8562    }
8563
8564    Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8565    {
8566      m_queue = {};
8567      return *this;
8568    }
8569
8570#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8571    auto operator<=>( Queue const & ) const = default;
8572#else
8573    bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
8574    {
8575      return m_queue == rhs.m_queue;
8576    }
8577
8578    bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
8579    {
8580      return m_queue != rhs.m_queue;
8581    }
8582
8583    bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
8584    {
8585      return m_queue < rhs.m_queue;
8586    }
8587#endif
8588
8589    //=== VK_VERSION_1_0 ===
8590
8591    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8592    VULKAN_HPP_NODISCARD Result submit( uint32_t                                 submitCount,
8593                                        const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
8594                                        VULKAN_HPP_NAMESPACE::Fence              fence,
8595                                        Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8596#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8597    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8598    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8599      submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
8600              VULKAN_HPP_NAMESPACE::Fence fence                                                VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8601              Dispatch const & d                                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8602#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8603
8604#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8605    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8606    VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8607#else
8608    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8609    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8610#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8611
8612    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8613    VULKAN_HPP_NODISCARD Result bindSparse( uint32_t                                     bindInfoCount,
8614                                            const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
8615                                            VULKAN_HPP_NAMESPACE::Fence                  fence,
8616                                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8617#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8618    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8619    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8620      bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
8621                  VULKAN_HPP_NAMESPACE::Fence fence                                                    VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8622                  Dispatch const & d                                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8623#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8624
8625    //=== VK_VERSION_1_3 ===
8626
8627    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8628    VULKAN_HPP_NODISCARD Result submit2( uint32_t                                  submitCount,
8629                                         const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
8630                                         VULKAN_HPP_NAMESPACE::Fence               fence,
8631                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8632#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8633    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8634    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8635      submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
8636               VULKAN_HPP_NAMESPACE::Fence fence                                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8637               Dispatch const & d                                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8638#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8639
8640    //=== VK_KHR_swapchain ===
8641
8642    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8643    VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
8644                                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8645#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8646    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8647    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo,
8648                                                                  Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8649#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8650
8651    //=== VK_EXT_debug_utils ===
8652
8653    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8654    void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
8655                                  Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8656#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8657    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8658    void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
8659                                  Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8660#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8661
8662    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8663    void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8664
8665    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8666    void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
8667                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8668#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8669    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8670    void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
8671                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8672#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8673
8674    //=== VK_NV_device_diagnostic_checkpoints ===
8675
8676    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8677    void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
8678                              VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
8679                              Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8680#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8681    template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
8682              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8683    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
8684                         getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8685    template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
8686              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8687              typename B1                        = CheckpointDataNVAllocator,
8688              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type = 0>
8689    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
8690      getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8691#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8692
8693    //=== VK_INTEL_performance_query ===
8694
8695#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8696    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8697    VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
8698                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8699#else
8700    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8701    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8702         setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
8703                                           Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8704#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8705
8706    //=== VK_KHR_synchronization2 ===
8707
8708    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8709    VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t                                  submitCount,
8710                                            const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
8711                                            VULKAN_HPP_NAMESPACE::Fence               fence,
8712                                            Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8713#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8714    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8715    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8716      submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
8717                  VULKAN_HPP_NAMESPACE::Fence fence                                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8718                  Dispatch const & d                                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8719#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8720
8721    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8722    void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
8723                               VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
8724                               Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8725#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8726    template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
8727              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8728    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
8729                         getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8730    template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
8731              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8732              typename B1                         = CheckpointData2NVAllocator,
8733              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type = 0>
8734    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
8735      getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8736#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8737
8738    //=== VK_NV_low_latency2 ===
8739
8740    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8741    void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo,
8742                            Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8743#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8744    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8745    void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo,
8746                            Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8747#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8748
8749    operator VkQueue() const VULKAN_HPP_NOEXCEPT
8750    {
8751      return m_queue;
8752    }
8753
8754    explicit operator bool() const VULKAN_HPP_NOEXCEPT
8755    {
8756      return m_queue != VK_NULL_HANDLE;
8757    }
8758
8759    bool operator!() const VULKAN_HPP_NOEXCEPT
8760    {
8761      return m_queue == VK_NULL_HANDLE;
8762    }
8763
8764  private:
8765    VkQueue m_queue = {};
8766  };
8767
8768  template <>
8769  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
8770  {
8771    using Type = VULKAN_HPP_NAMESPACE::Queue;
8772  };
8773
8774  template <>
8775  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
8776  {
8777    using Type = VULKAN_HPP_NAMESPACE::Queue;
8778  };
8779
8780  template <>
8781  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
8782  {
8783    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8784  };
8785
8786  class Device
8787  {
8788  public:
8789    using CType      = VkDevice;
8790    using NativeType = VkDevice;
8791
8792    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
8793    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8794      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
8795
8796  public:
8797    VULKAN_HPP_CONSTEXPR Device() = default;
8798
8799    VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8800
8801    Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
8802
8803    Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
8804    {
8805      m_device = device;
8806      return *this;
8807    }
8808
8809    Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8810    {
8811      m_device = {};
8812      return *this;
8813    }
8814
8815#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8816    auto operator<=>( Device const & ) const = default;
8817#else
8818    bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
8819    {
8820      return m_device == rhs.m_device;
8821    }
8822
8823    bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
8824    {
8825      return m_device != rhs.m_device;
8826    }
8827
8828    bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
8829    {
8830      return m_device < rhs.m_device;
8831    }
8832#endif
8833
8834    //=== VK_VERSION_1_0 ===
8835
8836    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8837    PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8838#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8839    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8840    PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8841#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8842
8843    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8844    void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8845                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8846#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8847    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8848    void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8849                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8850#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8851
8852    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8853    void getQueue( uint32_t                      queueFamilyIndex,
8854                   uint32_t                      queueIndex,
8855                   VULKAN_HPP_NAMESPACE::Queue * pQueue,
8856                   Dispatch const & d            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8857#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8858    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8859    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
8860      getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8861#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8862
8863#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8864    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8865    VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8866#else
8867    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8868    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8869#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8870
8871    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8872    VULKAN_HPP_NODISCARD Result allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *  pAllocateInfo,
8873                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8874                                                VULKAN_HPP_NAMESPACE::DeviceMemory *              pMemory,
8875                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8876#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8877    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8878    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type
8879      allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &                    allocateInfo,
8880                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8881                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8882#  ifndef VULKAN_HPP_NO_SMART_HANDLE
8883    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8884    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type
8885      allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &                    allocateInfo,
8886                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8887                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8888#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8889#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8890
8891    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8892    void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
8893                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8894                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8895#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8896    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8897    void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8898                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8899                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8900#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8901
8902    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8903    void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
8904                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8905                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8906#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8907    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8908    void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                                  memory,
8909                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8910                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8911#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8912
8913    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8914    VULKAN_HPP_NODISCARD Result mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
8915                                           VULKAN_HPP_NAMESPACE::DeviceSize     offset,
8916                                           VULKAN_HPP_NAMESPACE::DeviceSize     size,
8917                                           VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
8918                                           void **                              ppData,
8919                                           Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8920#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8921    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8922    VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory         memory,
8923                                                                           VULKAN_HPP_NAMESPACE::DeviceSize           offset,
8924                                                                           VULKAN_HPP_NAMESPACE::DeviceSize           size,
8925                                                                           VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8926                                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8927#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8928
8929    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8930    void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8931
8932    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8933    VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
8934                                                         const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
8935                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8936#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8937    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8938    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8939      flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
8940                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8941#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8942
8943    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8944    VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t                                        memoryRangeCount,
8945                                                              const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
8946                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8947#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8948    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8949    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8950      invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
8951                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8952#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8953
8954    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8955    void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8956                              VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
8957                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8958#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8959    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8960    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
8961      getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8962#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8963
8964#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8965    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8966    VULKAN_HPP_NODISCARD Result bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
8967                                                  VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8968                                                  VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
8969                                                  Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8970#else
8971    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8972    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8973      bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
8974                        VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8975                        VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
8976                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8977#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8978
8979#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8980    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8981    VULKAN_HPP_NODISCARD Result bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
8982                                                 VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8983                                                 VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
8984                                                 Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8985#else
8986    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8987    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8988      bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
8989                       VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8990                       VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
8991                       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8992#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8993
8994    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8995    void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
8996                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
8997                                      Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8998#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8999    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9000    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements
9001      getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9002#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9003
9004    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9005    void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
9006                                     VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
9007                                     Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9008#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9009    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9010    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements
9011      getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9012#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9013
9014    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9015    void getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                           image,
9016                                           uint32_t *                                            pSparseMemoryRequirementCount,
9017                                           VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
9018                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9019#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9020    template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
9021              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9022    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
9023      getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9024    template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
9025              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9026              typename B1                                     = SparseImageMemoryRequirementsAllocator,
9027              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value, int>::type = 0>
9028    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
9029                         getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
9030                                                           SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
9031                                                           Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9032#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9033
9034    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9035    VULKAN_HPP_NODISCARD Result createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
9036                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9037                                             VULKAN_HPP_NAMESPACE::Fence *                     pFence,
9038                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9039#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9040    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9041    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
9042      createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo &                       createInfo,
9043                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9044                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9045#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9046    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9047    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
9048      createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo &                       createInfo,
9049                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9050                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9051#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9052#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9053
9054    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9055    void destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
9056                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9057                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9058#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9059    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9060    void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9061                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9062                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9063#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9064
9065    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9066    void destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,
9067                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9068                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9069#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9070    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9071    void destroy( VULKAN_HPP_NAMESPACE::Fence                                         fence,
9072                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9073                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9074#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9075
9076    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9077    VULKAN_HPP_NODISCARD Result resetFences( uint32_t                            fenceCount,
9078                                             const VULKAN_HPP_NAMESPACE::Fence * pFences,
9079                                             Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9080#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9081    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9082    typename ResultValueType<void>::type resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
9083                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9084#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9085
9086#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9087    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9088    VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
9089                                                Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9090#else
9091    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9092    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
9093                                                                      Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9094#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9095
9096    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9097    VULKAN_HPP_NODISCARD Result waitForFences( uint32_t                            fenceCount,
9098                                               const VULKAN_HPP_NAMESPACE::Fence * pFences,
9099                                               VULKAN_HPP_NAMESPACE::Bool32        waitAll,
9100                                               uint64_t                            timeout,
9101                                               Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9102#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9103    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9104    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
9105                                                                     VULKAN_HPP_NAMESPACE::Bool32                                                waitAll,
9106                                                                     uint64_t                                                                    timeout,
9107                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9108#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9109
9110    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9111    VULKAN_HPP_NODISCARD Result createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
9112                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9113                                                 VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
9114                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9115#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9116    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9117    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
9118      createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &                   createInfo,
9119                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9120                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9121#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9122    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9123    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
9124      createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &                   createInfo,
9125                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9126                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9127#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9128#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9129
9130    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9131    void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
9132                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9133                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9134#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9135    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9136    void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9137                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9138                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9139#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9140
9141    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9142    void destroy( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
9143                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9144                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9145#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9146    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9147    void destroy( VULKAN_HPP_NAMESPACE::Semaphore                                     semaphore,
9148                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9149                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9150#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9151
9152    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9153    VULKAN_HPP_NODISCARD Result createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
9154                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9155                                             VULKAN_HPP_NAMESPACE::Event *                     pEvent,
9156                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9157#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9158    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9159    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
9160      createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo &                       createInfo,
9161                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9162                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9163#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9164    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9165    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
9166      createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo &                       createInfo,
9167                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9168                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9169#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9170#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9171
9172    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9173    void destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
9174                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9175                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9176#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9177    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9178    void destroyEvent( VULKAN_HPP_NAMESPACE::Event event                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9179                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9180                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9181#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9182
9183    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9184    void destroy( VULKAN_HPP_NAMESPACE::Event                       event,
9185                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9186                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9187#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9188    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9189    void destroy( VULKAN_HPP_NAMESPACE::Event                                         event,
9190                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9191                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9192#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9193
9194#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9195    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9196    VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
9197                                                Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9198#else
9199    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9200    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
9201                                                                      Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9202#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9203
9204#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9205    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9206    VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event,
9207                                          Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9208#else
9209    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9210    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setEvent( VULKAN_HPP_NAMESPACE::Event event,
9211                                                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9212#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9213
9214#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9215    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9216    VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event,
9217                                            Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9218#else
9219    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9220    typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9221#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9222
9223    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9224    VULKAN_HPP_NODISCARD Result createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
9225                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9226                                                 VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
9227                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9228#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9229    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9230    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
9231      createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &                   createInfo,
9232                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9233                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9234#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9235    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9236    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
9237      createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &                   createInfo,
9238                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9239                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9240#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9241#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9242
9243    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9244    void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
9245                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9246                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9247#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9248    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9249    void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9250                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9251                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9252#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9253
9254    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9255    void destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
9256                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9257                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9258#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9259    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9260    void destroy( VULKAN_HPP_NAMESPACE::QueryPool                                     queryPool,
9261                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9262                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9263#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9264
9265    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9266    VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
9267                                                     uint32_t                               firstQuery,
9268                                                     uint32_t                               queryCount,
9269                                                     size_t                                 dataSize,
9270                                                     void *                                 pData,
9271                                                     VULKAN_HPP_NAMESPACE::DeviceSize       stride,
9272                                                     VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
9273                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9274#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9275    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9276    VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>>
9277                         getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
9278                                              uint32_t                                     firstQuery,
9279                                              uint32_t                                     queryCount,
9280                                              size_t                                       dataSize,
9281                                              VULKAN_HPP_NAMESPACE::DeviceSize             stride,
9282                                              VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9283                                              Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9284    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9285    VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
9286                                                                   uint32_t                                     firstQuery,
9287                                                                   uint32_t                                     queryCount,
9288                                                                   VULKAN_HPP_NAMESPACE::DeviceSize             stride,
9289                                                                   VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9290                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9291#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9292
9293    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9294    VULKAN_HPP_NODISCARD Result createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo *    pCreateInfo,
9295                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9296                                              VULKAN_HPP_NAMESPACE::Buffer *                    pBuffer,
9297                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9298#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9299    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9300    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type
9301      createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo &                      createInfo,
9302                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9303                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9304#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9305    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9306    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type
9307      createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo &                      createInfo,
9308                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9309                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9310#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9311#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9312
9313    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9314    void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
9315                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9316                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9317#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9318    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9319    void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9320                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9321                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9322#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9323
9324    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9325    void destroy( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
9326                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9327                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9328#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9329    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9330    void destroy( VULKAN_HPP_NAMESPACE::Buffer                                        buffer,
9331                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9332                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9333#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9334
9335    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9336    VULKAN_HPP_NODISCARD Result createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
9337                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
9338                                                  VULKAN_HPP_NAMESPACE::BufferView *                 pView,
9339                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9340#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9341    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9342    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type
9343      createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &                  createInfo,
9344                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9345                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9346#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9347    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9348    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type
9349      createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &                  createInfo,
9350                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9351                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9352#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9353#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9354
9355    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9356    void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
9357                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9358                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9359#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9360    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9361    void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9362                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9363                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9364#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9365
9366    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9367    void destroy( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
9368                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9369                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9370#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9371    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9372    void destroy( VULKAN_HPP_NAMESPACE::BufferView                                    bufferView,
9373                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9374                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9375#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9376
9377    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9378    VULKAN_HPP_NODISCARD Result createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
9379                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9380                                             VULKAN_HPP_NAMESPACE::Image *                     pImage,
9381                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9382#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9383    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9384    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
9385      createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo &                       createInfo,
9386                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9387                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9388#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9389    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9390    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
9391      createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo &                       createInfo,
9392                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9393                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9394#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9395#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9396
9397    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9398    void destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
9399                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9400                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9401#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9402    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9403    void destroyImage( VULKAN_HPP_NAMESPACE::Image image                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9404                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9405                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9406#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9407
9408    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9409    void destroy( VULKAN_HPP_NAMESPACE::Image                       image,
9410                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9411                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9412#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9413    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9414    void destroy( VULKAN_HPP_NAMESPACE::Image                                         image,
9415                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9416                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9417#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9418
9419    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9420    void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
9421                                    const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
9422                                    VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
9423                                    Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9424#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9425    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9426    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout
9427                         getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
9428                                                    const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource,
9429                                                    Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9430#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9431
9432    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9433    VULKAN_HPP_NODISCARD Result createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
9434                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9435                                                 VULKAN_HPP_NAMESPACE::ImageView *                 pView,
9436                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9437#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9438    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9439    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
9440      createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &                   createInfo,
9441                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9442                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9443#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9444    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9445    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
9446      createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &                   createInfo,
9447                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9448                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9449#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9450#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9451
9452    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9453    void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
9454                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9455                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9456#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9457    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9458    void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9459                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9460                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9461#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9462
9463    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9464    void destroy( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
9465                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9466                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9467#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9468    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9469    void destroy( VULKAN_HPP_NAMESPACE::ImageView                                     imageView,
9470                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9471                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9472#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9473
9474    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9475    VULKAN_HPP_NODISCARD Result createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
9476                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
9477                                                    VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
9478                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9479#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9480    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9481    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
9482      createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,
9483                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9484                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9485#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9486    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9487    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
9488      createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,
9489                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9490                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9491#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9492#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9493
9494    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9495    void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
9496                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9497                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9498#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9499    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9500    void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule                     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9501                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9502                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9503#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9504
9505    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9506    void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
9507                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9508                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9509#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9510    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9511    void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                                  shaderModule,
9512                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9513                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9514#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9515
9516    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9517    VULKAN_HPP_NODISCARD Result createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
9518                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
9519                                                     VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
9520                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9521#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9522    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9523    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
9524      createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &               createInfo,
9525                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9526                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9527#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9528    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9529    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
9530      createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &               createInfo,
9531                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9532                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9533#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9534#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9535
9536    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9537    void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
9538                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9539                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9540#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9541    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9542    void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9543                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9544                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9545#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9546
9547    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9548    void destroy( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
9549                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9550                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9551#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9552    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9553    void destroy( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
9554                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9555                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9556#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9557
9558    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9559    VULKAN_HPP_NODISCARD Result getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9560                                                      size_t *                            pDataSize,
9561                                                      void *                              pData,
9562                                                      Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9563#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9564    template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9565    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
9566      getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9567    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
9568              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9569              typename B1                                                                               = Uint8_tAllocator,
9570              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
9571    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
9572      getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9573                            Uint8_tAllocator &                  uint8_tAllocator,
9574                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9575#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9576
9577    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9578    VULKAN_HPP_NODISCARD Result mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
9579                                                     uint32_t                                    srcCacheCount,
9580                                                     const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
9581                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9582#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9583    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9584    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9585      mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                                                 dstCache,
9586                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
9587                           Dispatch const & d                                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9588#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9589
9590    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9591    VULKAN_HPP_NODISCARD Result createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
9592                                                         uint32_t                                                 createInfoCount,
9593                                                         const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
9594                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
9595                                                         VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
9596                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9597#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9598    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9599    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
9600                         createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
9601                                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
9602                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9603                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9604    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
9605              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9606              typename B0                = PipelineAllocator,
9607              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
9608    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
9609                         createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
9610                                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
9611                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                        allocator,
9612                                                  PipelineAllocator &                                                                              pipelineAllocator,
9613                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9614    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9615    VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
9616                         createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
9617                                                 const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &            createInfo,
9618                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9619                                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9620#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9621    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9622              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
9623    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
9624                         createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
9625                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
9626                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9627                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9628    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9629              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
9630              typename B0                = PipelineAllocator,
9631              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
9632    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
9633                         createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
9634                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
9635                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                        allocator,
9636                                                        PipelineAllocator &                                                                              pipelineAllocator,
9637                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9638    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9639    VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
9640                         createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
9641                                                       const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &            createInfo,
9642                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9643                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9644#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9645#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9646
9647    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9648    VULKAN_HPP_NODISCARD Result createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
9649                                                        uint32_t                                                createInfoCount,
9650                                                        const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos,
9651                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
9652                                                        VULKAN_HPP_NAMESPACE::Pipeline *                        pPipelines,
9653                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9654#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9655    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9656    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
9657                         createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
9658                                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
9659                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9660                                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9661    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
9662              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9663              typename B0                = PipelineAllocator,
9664              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
9665    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
9666                         createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
9667                                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
9668                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                       allocator,
9669                                                 PipelineAllocator &                                                                             pipelineAllocator,
9670                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9671    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9672    VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
9673                         createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
9674                                                const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &             createInfo,
9675                                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9676                                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9677#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9678    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9679              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
9680    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
9681                         createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
9682                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
9683                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9684                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9685    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9686              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
9687              typename B0                = PipelineAllocator,
9688              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
9689    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
9690                         createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
9691                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
9692                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                       allocator,
9693                                                       PipelineAllocator &                                                                             pipelineAllocator,
9694                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9695    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9696    VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
9697                         createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
9698                                                      const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &             createInfo,
9699                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9700                                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9701#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9702#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9703
9704    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9705    void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
9706                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9707                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9708#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9709    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9710    void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9711                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9712                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9713#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9714
9715    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9716    void destroy( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
9717                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9718                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9719#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9720    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9721    void destroy( VULKAN_HPP_NAMESPACE::Pipeline                                      pipeline,
9722                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9723                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9724#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9725
9726    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9727    VULKAN_HPP_NODISCARD Result createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
9728                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
9729                                                      VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
9730                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9731#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9732    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9733    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
9734      createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &              createInfo,
9735                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9736                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9737#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9738    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9739    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
9740      createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &              createInfo,
9741                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9742                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9743#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9744#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9745
9746    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9747    void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
9748                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9749                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9750#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9751    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9752    void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9753                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9754                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9755#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9756
9757    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9758    void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
9759                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9760                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9761#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9762    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9763    void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout                                pipelineLayout,
9764                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9765                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9766#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9767
9768    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9769    VULKAN_HPP_NODISCARD Result createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
9770                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9771                                               VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
9772                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9773#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9774    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9775    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
9776      createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &                     createInfo,
9777                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9778                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9779#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9780    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9781    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
9782      createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &                     createInfo,
9783                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9784                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9785#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9786#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9787
9788    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9789    void destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
9790                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9791                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9792#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9793    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9794    void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler                               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9795                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9796                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9797#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9798
9799    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9800    void destroy( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
9801                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9802                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9803#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9804    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9805    void destroy( VULKAN_HPP_NAMESPACE::Sampler                                       sampler,
9806                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9807                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9808#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9809
9810    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9811    VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
9812                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
9813                                                           VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
9814                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9815#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9816    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9817    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
9818      createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &         createInfo,
9819                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9820                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9821#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9822    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9823    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
9824      createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &         createInfo,
9825                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9826                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9827#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9828#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9829
9830    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9831    void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
9832                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9833                                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9834#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9835    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9836    void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9837                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9838                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9839#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9840
9841    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9842    void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
9843                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9844                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9845#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9846    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9847    void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout                           descriptorSetLayout,
9848                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9849                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9850#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9851
9852    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9853    VULKAN_HPP_NODISCARD Result createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,
9854                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
9855                                                      VULKAN_HPP_NAMESPACE::DescriptorPool *                 pDescriptorPool,
9856                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9857#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9858    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9859    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type
9860      createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &              createInfo,
9861                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9862                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9863#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9864    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9865    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type
9866      createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &              createInfo,
9867                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9868                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9869#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9870#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9871
9872    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9873    void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
9874                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9875                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9876#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9877    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9878    void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9879                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9880                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9881#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9882
9883    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9884    void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
9885                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9886                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9887#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9888    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9889    void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool                                descriptorPool,
9890                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9891                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9892#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9893
9894#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9895    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9896    Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
9897                                VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
9898                                Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9899#else
9900    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9901    void resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool                 descriptorPool,
9902                              VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9903                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9904#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9905
9906    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9907    VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
9908                                                        VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
9909                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9910#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9911    template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9912    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
9913      allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
9914                              Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9915    template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>,
9916              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9917              typename B0                     = DescriptorSetAllocator,
9918              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type = 0>
9919    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
9920      allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
9921                              DescriptorSetAllocator &                                descriptorSetAllocator,
9922                              Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9923#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9924    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9925              typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>
9926    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
9927      allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
9928                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9929    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9930              typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>,
9931              typename B0                     = DescriptorSetAllocator,
9932              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value, int>::type = 0>
9933    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
9934      allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
9935                                    DescriptorSetAllocator &                                descriptorSetAllocator,
9936                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9937#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9938#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9939
9940    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9941    Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
9942                               uint32_t                                    descriptorSetCount,
9943                               const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
9944                               Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9945#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9946    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9947    void freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                                                descriptorPool,
9948                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
9949                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9950#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9951
9952    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9953    Result( free )( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
9954                    uint32_t                                    descriptorSetCount,
9955                    const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
9956                    Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9957#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9958    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9959    void( free )( VULKAN_HPP_NAMESPACE::DescriptorPool                                                descriptorPool,
9960                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
9961                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9962#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9963
9964    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9965    void updateDescriptorSets( uint32_t                                         descriptorWriteCount,
9966                               const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
9967                               uint32_t                                         descriptorCopyCount,
9968                               const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
9969                               Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9970#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9971    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9972    void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
9973                               VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
9974                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9975#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9976
9977    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9978    VULKAN_HPP_NODISCARD Result createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
9979                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
9980                                                   VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
9981                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9982#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9983    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9984    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
9985      createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &                 createInfo,
9986                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9987                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9988#  ifndef VULKAN_HPP_NO_SMART_HANDLE
9989    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9990    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
9991      createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &                 createInfo,
9992                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9993                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9994#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9995#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9996
9997    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9998    void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
9999                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10000                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10001#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10002    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10003    void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer                       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10004                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10005                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10006#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10007
10008    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10009    void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
10010                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10011                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10012#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10013    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10014    void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                                   framebuffer,
10015                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10016                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10017#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10018
10019    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10020    VULKAN_HPP_NODISCARD Result createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
10021                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
10022                                                  VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
10023                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10024#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10025    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10026    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
10027      createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &                  createInfo,
10028                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10029                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10030#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10031    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10032    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
10033      createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &                  createInfo,
10034                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10035                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10036#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10037#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10038
10039    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10040    void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
10041                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10042                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10043#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10044    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10045    void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10046                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10047                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10048#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10049
10050    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10051    void destroy( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
10052                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10053                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10054#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10055    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10056    void destroy( VULKAN_HPP_NAMESPACE::RenderPass                                    renderPass,
10057                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10058                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10059#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10060
10061    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10062    void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
10063                                   VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
10064                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10065#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10066    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10067    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
10068                         getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
10069                                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10070#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10071
10072    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10073    VULKAN_HPP_NODISCARD Result createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
10074                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
10075                                                   VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
10076                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10077#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10078    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10079    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
10080      createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &                 createInfo,
10081                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10082                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10083#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10084    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10085    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
10086      createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &                 createInfo,
10087                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10088                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10089#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10090#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10091
10092    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10093    void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
10094                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10095                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10096#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10097    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10098    void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool                       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10099                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10100                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10101#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10102
10103    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10104    void destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
10105                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10106                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10107#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10108    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10109    void destroy( VULKAN_HPP_NAMESPACE::CommandPool                                   commandPool,
10110                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10111                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10112#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10113
10114#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10115    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10116    VULKAN_HPP_NODISCARD Result resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
10117                                                  VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
10118                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10119#else
10120    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10121    typename ResultValueType<void>::type resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
10122                                                           VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10123                                                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10124#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10125
10126    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10127    VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
10128                                                        VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
10129                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10130#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10131    template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10132    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
10133      allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10134                              Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10135    template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>,
10136              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10137              typename B0                     = CommandBufferAllocator,
10138              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type = 0>
10139    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
10140      allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10141                              CommandBufferAllocator &                                commandBufferAllocator,
10142                              Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10143#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10144    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10145              typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>
10146    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
10147      allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10148                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10149    template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10150              typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>,
10151              typename B0                     = CommandBufferAllocator,
10152              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value, int>::type = 0>
10153    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
10154      allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10155                                    CommandBufferAllocator &                                commandBufferAllocator,
10156                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10157#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10158#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10159
10160    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10161    void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
10162                             uint32_t                                    commandBufferCount,
10163                             const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
10164                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10165#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10166    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10167    void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                                                   commandPool,
10168                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
10169                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10170#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10171
10172    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10173    void( free )( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
10174                  uint32_t                                    commandBufferCount,
10175                  const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
10176                  Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10177#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10178    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10179    void( free )( VULKAN_HPP_NAMESPACE::CommandPool                                                   commandPool,
10180                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
10181                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10182#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10183
10184    //=== VK_VERSION_1_1 ===
10185
10186    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10187    VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t                                           bindInfoCount,
10188                                                   const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
10189                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10190#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10191    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10192    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10193      bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
10194                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10195#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10196
10197    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10198    VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t                                          bindInfoCount,
10199                                                  const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
10200                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10201#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10202    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10203    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10204      bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
10205                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10206#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10207
10208    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10209    void getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
10210                                     uint32_t                                       localDeviceIndex,
10211                                     uint32_t                                       remoteDeviceIndex,
10212                                     VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
10213                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10214#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10215    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10216    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
10217                         getGroupPeerMemoryFeatures( uint32_t           heapIndex,
10218                                                     uint32_t           localDeviceIndex,
10219                                                     uint32_t           remoteDeviceIndex,
10220                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10221#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10222
10223    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10224    void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
10225                                      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
10226                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10227#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10228    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10229    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10230                         getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10231                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10232    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10233    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10234                         getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10235                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10236#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10237
10238    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10239    void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
10240                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
10241                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10242#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10243    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10244    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10245                         getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10246                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10247    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10248    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10249                         getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10250                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10251#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10252
10253    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10254    void getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
10255                                            uint32_t *                                                       pSparseMemoryRequirementCount,
10256                                            VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
10257                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10258#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10259    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10260              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10261    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10262                         getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10263                                                            Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10264    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10265              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10266              typename B1                                      = SparseImageMemoryRequirements2Allocator,
10267              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type = 0>
10268    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10269                         getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10270                                                            SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
10271                                                            Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10272#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10273
10274    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10275    void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
10276                          VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
10277                          Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10278
10279    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10280    void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
10281                    VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
10282                    Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10283#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10284    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10285    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo,
10286                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10287#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10288
10289    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10290    VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
10291                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
10292                                                              VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
10293                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10294#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10295    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10296    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
10297      createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
10298                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10299                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10300#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10301    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10302    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
10303      createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
10304                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10305                                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10306#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10307#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10308
10309    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10310    void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
10311                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10312                                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10313#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10314    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10315    void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10316                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10317                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10318#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10319
10320    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10321    void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
10322                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10323                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10324#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10325    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10326    void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion                        ycbcrConversion,
10327                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10328                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10329#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10330
10331    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10332    VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
10333                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
10334                                                                VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
10335                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10336#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10337    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10338    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
10339      createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,
10340                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10341                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10342#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10343    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10344    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
10345      createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,
10346                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10347                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10348#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10349#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10350
10351    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10352    void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
10353                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10354                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10355#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10356    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10357    void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10358                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10359                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10360#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10361
10362    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10363    void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
10364                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10365                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10366#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10367    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10368    void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate                      descriptorUpdateTemplate,
10369                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10370                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10371#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10372
10373    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10374    void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
10375                                          VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10376                                          const void *                                   pData,
10377                                          Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10378#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10379    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10380    void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
10381                                          VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10382                                          DataType const &                               data,
10383                                          Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10384#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10385
10386    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10387    void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
10388                                        VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
10389                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10390#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10391    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10392    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
10393                         getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
10394                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10395    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10396    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10397                         getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
10398                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10399#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10400
10401    //=== VK_VERSION_1_2 ===
10402
10403    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10404    VULKAN_HPP_NODISCARD Result createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
10405                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
10406                                                   VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
10407                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10408#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10409    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10410    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
10411      createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
10412                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10413                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10414#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10415    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10416    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
10417      createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
10418                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10419                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10420#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10421#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10422
10423    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10424    void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
10425                         uint32_t                        firstQuery,
10426                         uint32_t                        queryCount,
10427                         Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10428
10429    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10430    VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
10431                                                          uint64_t *                      pValue,
10432                                                          Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10433#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10434    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10435    VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
10436                                                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10437#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10438
10439    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10440    VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
10441                                                uint64_t                                        timeout,
10442                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10443#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10444    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10445    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
10446                                                                      uint64_t                                        timeout,
10447                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10448#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10449
10450    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10451    VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
10452                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10453#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10454    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10455    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10456      signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10457#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10458
10459    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10460    DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
10461                                    Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10462#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10463    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10464    VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
10465                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10466#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10467
10468    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10469    uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
10470                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10471#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10472    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10473    uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
10474                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10475#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10476
10477    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10478    uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
10479                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10480#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10481    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10482    uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
10483                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10484#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10485
10486    //=== VK_VERSION_1_3 ===
10487
10488    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10489    VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,
10490                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
10491                                                       VULKAN_HPP_NAMESPACE::PrivateDataSlot *                 pPrivateDataSlot,
10492                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10493#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10494    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10495    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type
10496      createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
10497                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10498                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10499#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10500    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10501    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type
10502      createPrivateDataSlotUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
10503                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10504                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10505#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10506#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10507
10508    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10509    void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,
10510                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10511                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10512#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10513    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10514    void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10515                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10516                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10517#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10518
10519    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10520    void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,
10521                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10522                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10523#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10524    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10525    void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot                               privateDataSlot,
10526                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10527                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10528#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10529
10530#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10531    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10532    VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
10533                                                uint64_t                              objectHandle,
10534                                                VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10535                                                uint64_t                              data,
10536                                                Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10537#else
10538    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10539    typename ResultValueType<void>::type setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
10540                                                         uint64_t                              objectHandle,
10541                                                         VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10542                                                         uint64_t                              data,
10543                                                         Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10544#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10545
10546    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10547    void getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
10548                         uint64_t                              objectHandle,
10549                         VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10550                         uint64_t *                            pData,
10551                         Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10552#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10553    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10554    VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
10555                                                  uint64_t                              objectHandle,
10556                                                  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10557                                                  Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10558#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10559
10560    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10561    void getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,
10562                                      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                  pMemoryRequirements,
10563                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10564#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10565    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10566    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10567                         getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
10568                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10569    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10570    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10571                         getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
10572                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10573#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10574
10575    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10576    void getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
10577                                     VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
10578                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10579#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10580    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10581    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10582                         getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
10583                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10584    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10585    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10586                         getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
10587                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10588#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10589
10590    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10591    void getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
10592                                           uint32_t *                                                  pSparseMemoryRequirementCount,
10593                                           VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *      pSparseMemoryRequirements,
10594                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10595#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10596    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10597              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10598    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10599                         getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
10600                                                           Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10601    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10602              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10603              typename B1                                      = SparseImageMemoryRequirements2Allocator,
10604              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type = 0>
10605    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10606                         getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
10607                                                           SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
10608                                                           Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10609#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10610
10611    //=== VK_KHR_swapchain ===
10612
10613    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10614    VULKAN_HPP_NODISCARD Result createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
10615                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
10616                                                    VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
10617                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10618#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10619    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10620    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
10621      createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
10622                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10623                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10624#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10625    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10626    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
10627      createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
10628                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10629                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10630#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10631#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10632
10633    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10634    void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
10635                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10636                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10637#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10638    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10639    void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain                        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10640                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10641                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10642#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10643
10644    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10645    void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
10646                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10647                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10648#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10649    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10650    void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                                  swapchain,
10651                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10652                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10653#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10654
10655    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10656    VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10657                                                       uint32_t *                         pSwapchainImageCount,
10658                                                       VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
10659                                                       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10660#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10661    template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10662    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type
10663      getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10664    template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>,
10665              typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10666              typename B1             = ImageAllocator,
10667              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type = 0>
10668    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR(
10669      VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10670#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10671
10672    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10673    VULKAN_HPP_NODISCARD Result acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10674                                                     uint64_t                           timeout,
10675                                                     VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
10676                                                     VULKAN_HPP_NAMESPACE::Fence        fence,
10677                                                     uint32_t *                         pImageIndex,
10678                                                     Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10679#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10680    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10681    VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR        swapchain,
10682                                                                    uint64_t                                  timeout,
10683                                                                    VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10684                                                                    VULKAN_HPP_NAMESPACE::Fence fence         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10685                                                                    Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10686#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10687
10688    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10689    VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
10690                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10691#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10692    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10693    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
10694      getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10695#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10696
10697    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10698    VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
10699                                                                VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
10700                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10701#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10702    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10703    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
10704      getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10705#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10706
10707    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10708    VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
10709                                                      uint32_t *                                            pImageIndex,
10710                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10711#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10712    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10713    VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo,
10714                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10715#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10716
10717    //=== VK_KHR_display_swapchain ===
10718
10719    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10720    VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t                                             swapchainCount,
10721                                                           const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
10722                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
10723                                                           VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
10724                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10725#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10726    template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10727    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
10728      createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
10729                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10730                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10731    template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>,
10732              typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10733              typename B0                    = SwapchainKHRAllocator,
10734              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type = 0>
10735    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
10736      createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
10737                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,
10738                                 SwapchainKHRAllocator &                                                                      swapchainKHRAllocator,
10739                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10740    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10741    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
10742      createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
10743                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10744                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10745#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10746    template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10747              typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>
10748    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
10749      createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
10750                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10751                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10752    template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10753              typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>,
10754              typename B0                    = SwapchainKHRAllocator,
10755              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value, int>::type = 0>
10756    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
10757      createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
10758                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,
10759                                       SwapchainKHRAllocator &                                                                      swapchainKHRAllocator,
10760                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10761    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10762    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
10763      createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
10764                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10765                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10766#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10767#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10768
10769    //=== VK_EXT_debug_marker ===
10770
10771    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10772    VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
10773                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10774#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10775    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10776    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10777      debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo,
10778                                  Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10779#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10780
10781    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10782    VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
10783                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10784#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10785    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10786    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10787      debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo,
10788                                   Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10789#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10790
10791    //=== VK_KHR_video_queue ===
10792
10793    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10794    VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
10795                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
10796                                                       VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
10797                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10798#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10799    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10800    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
10801      createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,
10802                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10803                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10804#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10805    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10806    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
10807      createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,
10808                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10809                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10810#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10811#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10812
10813    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10814    void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
10815                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10816                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10817#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10818    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10819    void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession                  VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10820                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10821                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10822#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10823
10824    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10825    void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
10826                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10827                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10828#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10829    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10830    void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR                               videoSession,
10831                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10832                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10833#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10834
10835    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10836    VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                     videoSession,
10837                                                                      uint32_t *                                                pMemoryRequirementsCount,
10838                                                                      VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements,
10839                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10840#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10841    template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
10842              typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10843    VULKAN_HPP_NODISCARD
10844      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
10845      getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
10846                                            Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10847    template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
10848              typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10849              typename B1                                         = VideoSessionMemoryRequirementsKHRAllocator,
10850              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value, int>::type = 0>
10851    VULKAN_HPP_NODISCARD
10852      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
10853      getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR        videoSession,
10854                                            VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,
10855                                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10856#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10857
10858    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10859    VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                       videoSession,
10860                                                           uint32_t                                                    bindSessionMemoryInfoCount,
10861                                                           const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,
10862                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10863#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10864    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10865    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10866      bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                                                               videoSession,
10867                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos,
10868                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10869#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10870
10871    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10872    VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
10873                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
10874                                                                 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
10875                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10876#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10877    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10878    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
10879      createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,
10880                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10881                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10882#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10883    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10884    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
10885      createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,
10886                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10887                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10888#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10889#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10890
10891    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10892    VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
10893                                                                 const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
10894                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10895#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10896    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10897    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10898      updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
10899                                       const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo,
10900                                       Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10901#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10902
10903    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10904    void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
10905                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10906                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10907#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10908    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10909    void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10910                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10911                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10912#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10913
10914    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10915    void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
10916                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10917                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10918#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10919    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10920    void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                     videoSessionParameters,
10921                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10922                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10923#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10924
10925    //=== VK_NVX_binary_import ===
10926
10927    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10928    VULKAN_HPP_NODISCARD Result createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
10929                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
10930                                                   VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
10931                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10932#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10933    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10934    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
10935      createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,
10936                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10937                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10938#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10939    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10940    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
10941      createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,
10942                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10943                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10944#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10945#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10946
10947    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10948    VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
10949                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
10950                                                     VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
10951                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10952#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10953    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10954    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
10955      createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,
10956                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10957                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10958#  ifndef VULKAN_HPP_NO_SMART_HANDLE
10959    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10960    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
10961      createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,
10962                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10963                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10964#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10965#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10966
10967    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10968    void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
10969                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10970                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10971#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10972    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10973    void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,
10974                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10975                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10976#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10977
10978    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10979    void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
10980                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10981                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10982#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10983    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10984    void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,
10985                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10986                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10987#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10988
10989    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10990    void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
10991                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10992                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10993#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10994    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10995    void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,
10996                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10997                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10998#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10999
11000    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11001    void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
11002                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11003                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11004#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11005    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11006    void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,
11007                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11008                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11009#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11010
11011    //=== VK_NVX_image_view_handle ===
11012
11013    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11014    uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
11015                                    Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11016#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11017    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11018    uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info,
11019                                    Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11020#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11021
11022    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11023    VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
11024                                                        VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
11025                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11026#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11027    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11028    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
11029      getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11030#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11031
11032    //=== VK_AMD_shader_info ===
11033
11034    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11035    VULKAN_HPP_NODISCARD Result getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
11036                                                  VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
11037                                                  VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
11038                                                  size_t *                                  pInfoSize,
11039                                                  void *                                    pInfo,
11040                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11041#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11042    template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11043    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
11044      getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
11045                        VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
11046                        VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
11047                        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11048    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
11049              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11050              typename B1                                                                               = Uint8_tAllocator,
11051              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
11052    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
11053      getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
11054                        VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
11055                        VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
11056                        Uint8_tAllocator &                        uint8_tAllocator,
11057                        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11058#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11059
11060#if defined( VK_USE_PLATFORM_WIN32_KHR )
11061    //=== VK_NV_external_memory_win32 ===
11062
11063    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11064    VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
11065                                                        VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
11066                                                        HANDLE *                                              pHandle,
11067                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11068#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11069    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11070    VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
11071                                                                                        VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
11072                                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11073#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11074#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
11075
11076    //=== VK_KHR_device_group ===
11077
11078    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11079    void getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
11080                                        uint32_t                                       localDeviceIndex,
11081                                        uint32_t                                       remoteDeviceIndex,
11082                                        VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
11083                                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11084#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11085    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11086    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
11087                         getGroupPeerMemoryFeaturesKHR( uint32_t           heapIndex,
11088                                                        uint32_t           localDeviceIndex,
11089                                                        uint32_t           remoteDeviceIndex,
11090                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11091#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11092
11093    //=== VK_KHR_maintenance1 ===
11094
11095    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11096    void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
11097                             VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
11098                             Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11099
11100#if defined( VK_USE_PLATFORM_WIN32_KHR )
11101    //=== VK_KHR_external_memory_win32 ===
11102
11103    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11104    VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
11105                                                         HANDLE *                                                  pHandle,
11106                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11107#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11108    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11109    VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type
11110      getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
11111                               Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11112#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11113
11114    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11115    VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11116                                                                   HANDLE                                                 handle,
11117                                                                   VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
11118                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11119#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11120    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11121    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR(
11122      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11123#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11124#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
11125
11126    //=== VK_KHR_external_memory_fd ===
11127
11128    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11129    VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
11130                                                int *                                            pFd,
11131                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11132#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11133    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11134    VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo,
11135                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11136#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11137
11138    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11139    VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11140                                                          int                                                    fd,
11141                                                          VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
11142                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11143#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11144    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11145    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR(
11146      VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11147#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11148
11149#if defined( VK_USE_PLATFORM_WIN32_KHR )
11150    //=== VK_KHR_external_semaphore_win32 ===
11151
11152    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11153    VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
11154                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11155#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11156    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11157    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11158      importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
11159                                     Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11160#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11161
11162    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11163    VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
11164                                                            HANDLE *                                                     pHandle,
11165                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11166#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11167    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11168    VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type
11169      getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
11170                                  Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11171#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11172#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
11173
11174    //=== VK_KHR_external_semaphore_fd ===
11175
11176    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11177    VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
11178                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11179#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11180    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11181    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11182      importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
11183                            Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11184#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11185
11186    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11187    VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
11188                                                   int *                                               pFd,
11189                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11190#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11191    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11192    VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo,
11193                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11194#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11195
11196    //=== VK_KHR_descriptor_update_template ===
11197
11198    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11199    VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
11200                                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
11201                                                                   VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
11202                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11203#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11204    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11205    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
11206      createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,
11207                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11208                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11209#  ifndef VULKAN_HPP_NO_SMART_HANDLE
11210    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11211    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
11212      createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
11213                                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11214                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11215                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11216#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11217#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11218
11219    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11220    void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
11221                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11222                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11223#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11224    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11225    void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11226                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11227                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11228#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11229
11230    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11231    void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
11232                                             VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11233                                             const void *                                   pData,
11234                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11235#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11236    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11237    void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
11238                                             VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11239                                             DataType const &                               data,
11240                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11241#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11242
11243    //=== VK_EXT_display_control ===
11244
11245    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11246    VULKAN_HPP_NODISCARD Result displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
11247                                                        const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
11248                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11249#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11250    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11251    typename ResultValueType<void>::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
11252                                                                 const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo,
11253                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11254#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11255
11256    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11257    VULKAN_HPP_NODISCARD Result registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
11258                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11259                                                  VULKAN_HPP_NAMESPACE::Fence *                     pFence,
11260                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11261#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11262    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11263    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
11264      registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &                    deviceEventInfo,
11265                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11266                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11267#  ifndef VULKAN_HPP_NO_SMART_HANDLE
11268    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11269    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
11270      registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &                    deviceEventInfo,
11271                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11272                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11273#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11274#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11275
11276    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11277    VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
11278                                                         const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
11279                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11280                                                         VULKAN_HPP_NAMESPACE::Fence *                     pFence,
11281                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11282#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11283    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11284    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
11285      registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
11286                               const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &                   displayEventInfo,
11287                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11288                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11289#  ifndef VULKAN_HPP_NO_SMART_HANDLE
11290    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11291    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
11292      registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
11293                                     const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &                   displayEventInfo,
11294                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11295                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11296#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11297#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11298
11299    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11300    VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
11301                                                        VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
11302                                                        uint64_t *                                      pCounterValue,
11303                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11304#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11305    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11306    VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
11307                                                                                          VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
11308                                                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11309#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11310
11311    //=== VK_GOOGLE_display_timing ===
11312
11313    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11314    VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
11315                                                               VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
11316                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11317#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11318    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11319    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
11320      getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11321#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11322
11323    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11324    VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
11325                                                                 uint32_t *                                           pPresentationTimingCount,
11326                                                                 VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
11327                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11328#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11329    template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
11330              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11331    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
11332      getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11333    template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
11334              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11335              typename B1                                    = PastPresentationTimingGOOGLEAllocator,
11336              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value, int>::type = 0>
11337    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
11338      getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
11339                                       PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
11340                                       Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11341#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11342
11343    //=== VK_EXT_hdr_metadata ===
11344
11345    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11346    void setHdrMetadataEXT( uint32_t                                     swapchainCount,
11347                            const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
11348                            const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
11349                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11350#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11351    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11352    void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
11353                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
11354                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
11355#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11356
11357    //=== VK_KHR_create_renderpass2 ===
11358
11359    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11360    VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
11361                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
11362                                                      VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
11363                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11364#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11365    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11366    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
11367      createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
11368                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11369                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11370#  ifndef VULKAN_HPP_NO_SMART_HANDLE
11371    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11372    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
11373      createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
11374                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11375                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11376#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11377#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11378
11379    //=== VK_KHR_shared_presentable_image ===
11380
11381#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11382    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11383    VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11384                                                       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11385#else
11386    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11387    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11388                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11389#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11390
11391#if defined( VK_USE_PLATFORM_WIN32_KHR )
11392    //=== VK_KHR_external_fence_win32 ===
11393
11394    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11395    VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
11396                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11397#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11398    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11399    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11400      importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
11401                                 Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11402#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11403
11404    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11405    VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
11406                                                        HANDLE *                                                 pHandle,
11407                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11408#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11409    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11410    VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type
11411      getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
11412                              Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11413#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11414#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
11415
11416    //=== VK_KHR_external_fence_fd ===
11417
11418    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11419    VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
11420                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11421#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11422    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11423    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11424      importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo,
11425                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11426#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11427
11428    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11429    VULKAN_HPP_NODISCARD Result getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
11430                                               int *                                           pFd,
11431                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11432#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11433    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11434    VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo,
11435                                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11436#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11437
11438    //=== VK_KHR_performance_query ===
11439
11440    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11441    VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
11442                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11443#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11444    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11445    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11446      acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info,
11447                               Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11448#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11449
11450    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11451    void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11452
11453    //=== VK_EXT_debug_utils ===
11454
11455    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11456    VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
11457                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11458#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11459    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11460    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11461      setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo,
11462                                  Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11463#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11464
11465    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11466    VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
11467                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11468#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11469    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11470    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11471      setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo,
11472                                 Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11473#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11474
11475#if defined( VK_USE_PLATFORM_ANDROID_KHR )
11476    //=== VK_ANDROID_external_memory_android_hardware_buffer ===
11477
11478    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11479    VULKAN_HPP_NODISCARD Result
11480      getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer *                                 buffer,
11481                                                 VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
11482                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11483#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11484    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11485    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
11486      getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11487    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11488    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
11489      getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11490#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11491
11492    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11493    VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
11494                                                                       struct AHardwareBuffer **                                               pBuffer,
11495                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11496#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11497    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11498    VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type
11499      getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info,
11500                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11501#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11502#endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
11503
11504#if defined( VK_ENABLE_BETA_EXTENSIONS )
11505    //=== VK_AMDX_shader_enqueue ===
11506
11507    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11508    VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache                                pipelineCache,
11509                                                                   uint32_t                                                           createInfoCount,
11510                                                                   const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
11511                                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
11512                                                                   VULKAN_HPP_NAMESPACE::Pipeline *                                   pPipelines,
11513                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11514#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11515    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11516    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11517                         createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11518                                                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
11519                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11520                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11521    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
11522              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11523              typename B0                = PipelineAllocator,
11524              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
11525    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11526                         createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11527                                                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
11528                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                                  allocator,
11529                                                            PipelineAllocator & pipelineAllocator,
11530                                                            Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11531    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11532    VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
11533                         createExecutionGraphPipelineAMDX( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
11534                                                           const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX &  createInfo,
11535                                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11536                                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11537#    ifndef VULKAN_HPP_NO_SMART_HANDLE
11538    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11539              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
11540    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
11541                         createExecutionGraphPipelinesAMDXUnique(
11542                           VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,
11543                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
11544                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11545                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11546    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11547              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
11548              typename B0                = PipelineAllocator,
11549              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
11550    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
11551                         createExecutionGraphPipelinesAMDXUnique(
11552                           VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,
11553                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
11554                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                                  allocator,
11555                           PipelineAllocator &                                                                                        pipelineAllocator,
11556                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11557    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11558    VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createExecutionGraphPipelineAMDXUnique(
11559      VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
11560      const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX &  createInfo,
11561      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11562      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11563#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
11564#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11565
11566    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11567    VULKAN_HPP_NODISCARD Result
11568      getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                executionGraph,
11569                                                VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo,
11570                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11571#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11572    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11573    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX>::type
11574      getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph,
11575                                                Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11576#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11577
11578    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11579    VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                      executionGraph,
11580                                                                        const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
11581                                                                        uint32_t *                                                          pNodeIndex,
11582                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11583#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11584    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11585    VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type
11586      getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                      executionGraph,
11587                                              const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo,
11588                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11589#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11590#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
11591
11592    //=== VK_KHR_get_memory_requirements2 ===
11593
11594    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11595    void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
11596                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
11597                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11598#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11599    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11600    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
11601                         getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
11602                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11603    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11604    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11605                         getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
11606                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11607#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11608
11609    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11610    void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
11611                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
11612                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11613#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11614    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11615    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
11616                         getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
11617                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11618    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11619    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11620                         getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
11621                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11622#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11623
11624    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11625    void getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
11626                                               uint32_t *                                                       pSparseMemoryRequirementCount,
11627                                               VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
11628                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11629#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11630    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
11631              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11632    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11633                         getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
11634                                                               Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11635    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
11636              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11637              typename B1                                      = SparseImageMemoryRequirements2Allocator,
11638              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type = 0>
11639    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11640                         getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
11641                                                               SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
11642                                                               Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11643#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11644
11645    //=== VK_KHR_acceleration_structure ===
11646
11647    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11648    VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
11649                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
11650                                                                VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
11651                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11652#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11653    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11654    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
11655      createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,
11656                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11657                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11658#  ifndef VULKAN_HPP_NO_SMART_HANDLE
11659    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11660    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
11661      createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,
11662                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11663                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11664#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11665#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11666
11667    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11668    void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
11669                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11670                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11671#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11672    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11673    void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11674                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11675                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11676#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11677
11678    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11679    void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
11680                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11681                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11682#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11683    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11684    void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR                      accelerationStructure,
11685                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11686                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11687#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11688
11689    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11690    VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
11691                                                                uint32_t                                                                     infoCount,
11692                                                                const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
11693                                                                const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
11694                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11695#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11696    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11697    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR(
11698      VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                                           deferredOperation,
11699      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
11700      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
11701      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11702#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11703
11704    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11705    VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
11706                                                              const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
11707                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11708#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11709    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11710    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11711                                                                                    const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
11712                                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11713#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11714
11715    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11716    VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
11717                                                                      const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
11718                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11719#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11720    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11721    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
11722                         copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
11723                                                               const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
11724                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11725#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11726
11727    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11728    VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
11729                                                                      const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
11730                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11731#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11732    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11733    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
11734                         copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
11735                                                               const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
11736                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11737#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11738
11739    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11740    VULKAN_HPP_NODISCARD Result
11741      writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,
11742                                                const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
11743                                                VULKAN_HPP_NAMESPACE::QueryType                        queryType,
11744                                                size_t                                                 dataSize,
11745                                                void *                                                 pData,
11746                                                size_t                                                 stride,
11747                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11748#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11749    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11750    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeAccelerationStructuresPropertiesKHR(
11751      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
11752      VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,
11753      size_t                                                                                         dataSize,
11754      size_t                                                                                         stride,
11755      Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11756    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11757    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeAccelerationStructuresPropertyKHR(
11758      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
11759      VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,
11760      size_t                                                                                         stride,
11761      Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11762#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11763
11764    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11765    DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
11766                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11767#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11768    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11769    VULKAN_HPP_NAMESPACE::DeviceAddress
11770      getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info,
11771                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11772#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11773
11774    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11775    void getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
11776                                                   VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
11777                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11778#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11779    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11780    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
11781                         getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo,
11782                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11783#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11784
11785    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11786    void getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
11787                                                const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
11788                                                const uint32_t *                                                        pMaxPrimitiveCounts,
11789                                                VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
11790                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11791#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11792    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11793    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(
11794      VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                     buildType,
11795      const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR &     buildInfo,
11796      VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11797      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
11798#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11799
11800    //=== VK_KHR_ray_tracing_pipeline ===
11801
11802    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11803    VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
11804                                                              VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
11805                                                              uint32_t                                                      createInfoCount,
11806                                                              const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,
11807                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *             pAllocator,
11808                                                              VULKAN_HPP_NAMESPACE::Pipeline *                              pPipelines,
11809                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11810#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11811    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11812    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11813                         createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,
11814                                                       VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,
11815                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11816                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11817                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11818    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
11819              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11820              typename B0                = PipelineAllocator,
11821              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
11822    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11823                         createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,
11824                                                       VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,
11825                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11826                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,
11827                                                       PipelineAllocator &                                                                                   pipelineAllocator,
11828                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11829    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11830    VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
11831                         createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,
11832                                                      VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
11833                                                      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,
11834                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11835                                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11836#  ifndef VULKAN_HPP_NO_SMART_HANDLE
11837    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11838              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
11839    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
11840                         createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11841                                                             VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
11842                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11843                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11844                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11845    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11846              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
11847              typename B0                = PipelineAllocator,
11848              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
11849    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
11850                         createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11851                                                             VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
11852                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11853                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,
11854                                                             PipelineAllocator & pipelineAllocator,
11855                                                             Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11856    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11857    VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
11858                         createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,
11859                                                            VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
11860                                                            const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,
11861                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11862                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11863#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11864#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11865
11866    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11867    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11868                                                                    uint32_t                       firstGroup,
11869                                                                    uint32_t                       groupCount,
11870                                                                    size_t                         dataSize,
11871                                                                    void *                         pData,
11872                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11873#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11874    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11875    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
11876      getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11877                                          uint32_t                       firstGroup,
11878                                          uint32_t                       groupCount,
11879                                          size_t                         dataSize,
11880                                          Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11881    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11882    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR(
11883      VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11884#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11885
11886    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11887    VULKAN_HPP_NODISCARD Result
11888      getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11889                                                       uint32_t                       firstGroup,
11890                                                       uint32_t                       groupCount,
11891                                                       size_t                         dataSize,
11892                                                       void *                         pData,
11893                                                       Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11894#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11895    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11896    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
11897      getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11898                                                       uint32_t                       firstGroup,
11899                                                       uint32_t                       groupCount,
11900                                                       size_t                         dataSize,
11901                                                       Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11902    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11903    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR(
11904      VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11905#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11906
11907    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11908    DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline             pipeline,
11909                                                     uint32_t                                   group,
11910                                                     VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader,
11911                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11912
11913    //=== VK_KHR_sampler_ycbcr_conversion ===
11914
11915    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11916    VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
11917                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
11918                                                                 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
11919                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11920#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11921    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11922    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
11923      createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
11924                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11925                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11926#  ifndef VULKAN_HPP_NO_SMART_HANDLE
11927    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11928    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
11929      createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
11930                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11931                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11932#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11933#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11934
11935    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11936    void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
11937                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11938                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11939#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11940    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11941    void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11942                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11943                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11944#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11945
11946    //=== VK_KHR_bind_memory2 ===
11947
11948    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11949    VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
11950                                                      const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
11951                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11952#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11953    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11954    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11955      bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
11956                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11957#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11958
11959    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11960    VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t                                          bindInfoCount,
11961                                                     const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
11962                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11963#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11964    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11965    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11966      bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
11967                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11968#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11969
11970    //=== VK_EXT_image_drm_format_modifier ===
11971
11972    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11973    VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image                                 image,
11974                                                                        VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
11975                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11976#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11977    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11978    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
11979      getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11980#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11981
11982    //=== VK_EXT_validation_cache ===
11983
11984    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11985    VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
11986                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
11987                                                          VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
11988                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11989#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11990    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11991    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type
11992      createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,
11993                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11994                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11995#  ifndef VULKAN_HPP_NO_SMART_HANDLE
11996    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11997    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
11998      createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,
11999                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12000                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12001#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12002#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12003
12004    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12005    void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
12006                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12007                                    Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12008#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12009    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12010    void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache            VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12011                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12012                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12013#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12014
12015    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12016    void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
12017                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12018                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12019#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12020    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12021    void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                            validationCache,
12022                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12023                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12024#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12025
12026    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12027    VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
12028                                                          uint32_t                                         srcCacheCount,
12029                                                          const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
12030                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12031#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12032    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12033    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12034      mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                                                 dstCache,
12035                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
12036                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12037#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12038
12039    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12040    VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
12041                                                           size_t *                                 pDataSize,
12042                                                           void *                                   pData,
12043                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12044#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12045    template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12046    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
12047      getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12048    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
12049              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12050              typename B1                                                                               = Uint8_tAllocator,
12051              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
12052    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
12053      getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
12054                                 Uint8_tAllocator &                       uint8_tAllocator,
12055                                 Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12056#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12057
12058    //=== VK_NV_ray_tracing ===
12059
12060    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12061    VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
12062                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
12063                                                               VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,
12064                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12065#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12066    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12067    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type
12068      createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,
12069                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12070                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12071#  ifndef VULKAN_HPP_NO_SMART_HANDLE
12072    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12073    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
12074      createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,
12075                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12076                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12077#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12078#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12079
12080    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12081    void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
12082                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12083                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12084#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12085    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12086    void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12087                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12088                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12089#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12090
12091    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12092    void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
12093                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12094                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12095#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12096    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12097    void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV                       accelerationStructure,
12098                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12099                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12100#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12101
12102    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12103    void getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
12104                                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
12105                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12106#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12107    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12108    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR
12109                         getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
12110                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12111    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12112    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12113                         getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
12114                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12115#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12116
12117    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12118    VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t                                                            bindInfoCount,
12119                                                                   const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
12120                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12121#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12122    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12123    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12124      bindAccelerationStructureMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
12125                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12126#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12127
12128    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12129    VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
12130                                                             uint32_t                                                     createInfoCount,
12131                                                             const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
12132                                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
12133                                                             VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
12134                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12135#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12136    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12137    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
12138                         createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
12139                                                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12140                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12141                                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12142    template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
12143              typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12144              typename B0                = PipelineAllocator,
12145              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
12146    VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
12147                         createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
12148                                                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12149                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,
12150                                                      PipelineAllocator &                                                                                  pipelineAllocator,
12151                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12152    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12153    VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
12154                         createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
12155                                                     const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,
12156                                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12157                                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12158#  ifndef VULKAN_HPP_NO_SMART_HANDLE
12159    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12160              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
12161    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
12162                         createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
12163                                                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12164                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12165                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12166    template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12167              typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
12168              typename B0                = PipelineAllocator,
12169              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value, int>::type = 0>
12170    VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
12171                         createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
12172                                                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12173                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,
12174                                                            PipelineAllocator &                                                                                  pipelineAllocator,
12175                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12176    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12177    VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
12178                         createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
12179                                                           const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,
12180                                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12181                                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12182#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12183#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12184
12185    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12186    VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12187                                                                   uint32_t                       firstGroup,
12188                                                                   uint32_t                       groupCount,
12189                                                                   size_t                         dataSize,
12190                                                                   void *                         pData,
12191                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12192#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12193    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12194    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
12195      getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12196                                         uint32_t                       firstGroup,
12197                                         uint32_t                       groupCount,
12198                                         size_t                         dataSize,
12199                                         Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12200    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12201    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV(
12202      VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12203#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12204
12205    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12206    VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
12207                                                                  size_t                                        dataSize,
12208                                                                  void *                                        pData,
12209                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12210#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12211    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12212    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV(
12213      VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12214    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12215    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
12216      getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
12217                                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12218#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12219
12220#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12221    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12222    VULKAN_HPP_NODISCARD Result compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12223                                                   uint32_t                       shader,
12224                                                   Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12225#else
12226    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12227    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12228      compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12229#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12230
12231    //=== VK_KHR_maintenance3 ===
12232
12233    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12234    void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
12235                                           VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
12236                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12237#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12238    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12239    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
12240                         getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
12241                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12242    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12243    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12244                         getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
12245                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12246#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12247
12248    //=== VK_EXT_external_memory_host ===
12249
12250    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12251    VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
12252                                                                   const void *                                           pHostPointer,
12253                                                                   VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
12254                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12255#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12256    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12257    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
12258      getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
12259                                         const void *                                           pHostPointer,
12260                                         Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12261#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12262
12263    //=== VK_EXT_calibrated_timestamps ===
12264
12265    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12266    VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t                                                 timestampCount,
12267                                                            const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
12268                                                            uint64_t *                                               pTimestamps,
12269                                                            uint64_t *                                               pMaxDeviation,
12270                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12271#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12272    template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12273    VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
12274      getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
12275                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12276    template <typename Uint64_tAllocator                                                                 = std::allocator<uint64_t>,
12277              typename Dispatch                                                                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12278              typename B0                                                                                = Uint64_tAllocator,
12279              typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type = 0>
12280    VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
12281      getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
12282                                  Uint64_tAllocator &                                                                              uint64_tAllocator,
12283                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12284    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12285    VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
12286      getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
12287                                 Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12288#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12289
12290    //=== VK_KHR_timeline_semaphore ===
12291
12292    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12293    VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
12294                                                             uint64_t *                      pValue,
12295                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12296#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12297    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12298    VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type
12299      getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12300#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12301
12302    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12303    VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
12304                                                   uint64_t                                        timeout,
12305                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12306#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12307    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12308    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
12309                                                                         uint64_t                                        timeout,
12310                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12311#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12312
12313    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12314    VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
12315                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12316#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12317    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12318    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12319      signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12320#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12321
12322    //=== VK_INTEL_performance_query ===
12323
12324    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12325    VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
12326                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12327#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12328    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12329    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12330      initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo,
12331                                     Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12332#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12333
12334    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12335    void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12336
12337    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12338    VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
12339                                                                      VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
12340                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12341#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12342    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12343    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
12344      acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
12345                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12346#  ifndef VULKAN_HPP_NO_SMART_HANDLE
12347    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12348    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
12349      acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
12350                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12351#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12352#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12353
12354#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12355    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12356    VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
12357                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12358#else
12359    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12360    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12361      releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12362                                            Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12363#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12364
12365#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12366    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12367    VULKAN_HPP_NODISCARD Result release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
12368                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12369#else
12370    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12371    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
12372                                                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12373#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12374
12375    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12376    VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
12377                                                              VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
12378                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12379#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12380    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12381    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
12382      getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
12383                                    Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12384#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12385
12386    //=== VK_AMD_display_native_hdr ===
12387
12388    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12389    void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
12390                             VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
12391                             Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12392
12393    //=== VK_EXT_buffer_device_address ===
12394
12395    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12396    DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
12397                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12398#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12399    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12400    VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
12401                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12402#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12403
12404    //=== VK_KHR_present_wait ===
12405
12406#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12407    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12408    VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12409                                                   uint64_t                           presentId,
12410                                                   uint64_t                           timeout,
12411                                                   Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12412#else
12413    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12414    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12415                                                                         uint64_t                           presentId,
12416                                                                         uint64_t                           timeout,
12417                                                                         Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12418#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12419
12420#if defined( VK_USE_PLATFORM_WIN32_KHR )
12421    //=== VK_EXT_full_screen_exclusive ===
12422
12423#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12424    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12425    VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12426                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12427#  else
12428    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12429    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12430      acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12431#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12432
12433#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12434    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12435    VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12436                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12437#  else
12438    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12439    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12440      releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12441#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12442
12443    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12444    VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
12445                                                                 VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
12446                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12447#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12448    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12449    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
12450      getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
12451                                       Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12452#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12453#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
12454
12455    //=== VK_KHR_buffer_device_address ===
12456
12457    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12458    DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
12459                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12460#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12461    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12462    VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
12463                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12464#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12465
12466    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12467    uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
12468                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12469#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12470    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12471    uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
12472                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12473#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12474
12475    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12476    uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
12477                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12478#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12479    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12480    uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
12481                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12482#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12483
12484    //=== VK_EXT_host_query_reset ===
12485
12486    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12487    void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
12488                            uint32_t                        firstQuery,
12489                            uint32_t                        queryCount,
12490                            Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12491
12492    //=== VK_KHR_deferred_host_operations ===
12493
12494    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12495    VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12496                                                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
12497                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12498#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12499    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12500    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type
12501      createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12502                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12503#  ifndef VULKAN_HPP_NO_SMART_HANDLE
12504    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12505    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
12506      createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12507                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12508#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12509#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12510
12511    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12512    void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
12513                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12514                                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12515#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12516    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12517    void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation                VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12518                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12519                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12520#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12521
12522    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12523    void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
12524                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12525                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12526#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12527    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12528    void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          operation,
12529                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12530                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12531#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12532
12533    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12534    uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12535                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12536
12537#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12538    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12539    VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12540                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12541#else
12542    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12543    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
12544                         getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12545                                                        Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12546#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12547
12548#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12549    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12550    VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12551                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12552#else
12553    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12554    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12555                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12556#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12557
12558    //=== VK_KHR_pipeline_executable_properties ===
12559
12560    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12561    VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,
12562                                                                    uint32_t *                                              pExecutableCount,
12563                                                                    VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
12564                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12565#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12566    template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
12567              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12568    VULKAN_HPP_NODISCARD
12569      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
12570      getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
12571                                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12572    template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
12573              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12574              typename B1                                       = PipelineExecutablePropertiesKHRAllocator,
12575              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value, int>::type = 0>
12576    VULKAN_HPP_NODISCARD
12577      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
12578      getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
12579                                          PipelineExecutablePropertiesKHRAllocator &    pipelineExecutablePropertiesKHRAllocator,
12580                                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12581#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12582
12583    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12584    VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
12585                                                                    uint32_t *                                              pStatisticCount,
12586                                                                    VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
12587                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12588#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12589    template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
12590              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12591    VULKAN_HPP_NODISCARD
12592      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
12593      getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
12594                                          Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12595    template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
12596              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12597              typename B1                                      = PipelineExecutableStatisticKHRAllocator,
12598              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value, int>::type = 0>
12599    VULKAN_HPP_NODISCARD
12600      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
12601      getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
12602                                          PipelineExecutableStatisticKHRAllocator &               pipelineExecutableStatisticKHRAllocator,
12603                                          Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12604#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12605
12606    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12607    VULKAN_HPP_NODISCARD Result
12608      getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
12609                                                       uint32_t *                                                          pInternalRepresentationCount,
12610                                                       VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
12611                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12612#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12613    template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
12614              typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12615    VULKAN_HPP_NODISCARD typename ResultValueType<
12616      std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
12617      getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
12618                                                       Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12619    template <
12620      typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
12621      typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12622      typename B1                                                   = PipelineExecutableInternalRepresentationKHRAllocator,
12623      typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value, int>::type = 0>
12624    VULKAN_HPP_NODISCARD typename ResultValueType<
12625      std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
12626      getPipelineExecutableInternalRepresentationsKHR(
12627        const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
12628        PipelineExecutableInternalRepresentationKHRAllocator &  pipelineExecutableInternalRepresentationKHRAllocator,
12629        Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12630#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12631
12632    //=== VK_EXT_host_image_copy ===
12633
12634    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12635    VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT * pCopyMemoryToImageInfo,
12636                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12637#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12638    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12639    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12640      copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT & copyMemoryToImageInfo,
12641                            Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12642#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12643
12644    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12645    VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT * pCopyImageToMemoryInfo,
12646                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12647#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12648    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12649    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12650      copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT & copyImageToMemoryInfo,
12651                            Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12652#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12653
12654    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12655    VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT * pCopyImageToImageInfo,
12656                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12657#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12658    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12659    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12660      copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT & copyImageToImageInfo,
12661                           Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12662#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12663
12664    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12665    VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t                                                       transitionCount,
12666                                                          const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT * pTransitions,
12667                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12668#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12669    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12670    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12671      transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> const & transitions,
12672                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12673#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12674
12675    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12676    void getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,
12677                                        const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource,
12678                                        VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR *      pLayout,
12679                                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12680#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12681    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12682    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
12683                         getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,
12684                                                        const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
12685                                                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12686    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12687    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12688                         getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,
12689                                                        const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
12690                                                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12691#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12692
12693    //=== VK_KHR_map_memory2 ===
12694
12695    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12696    VULKAN_HPP_NODISCARD Result mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR * pMemoryMapInfo,
12697                                               void **                                        ppData,
12698                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12699#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12700    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12701    VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo,
12702                                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12703#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12704
12705    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12706    Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo,
12707                            Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12708#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12709    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12710    void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo,
12711                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12712#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12713
12714    //=== VK_EXT_swapchain_maintenance1 ===
12715
12716    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12717    VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT * pReleaseInfo,
12718                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12719#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12720    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12721    typename ResultValueType<void>::type releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo,
12722                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12723#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12724
12725    //=== VK_NV_device_generated_commands ===
12726
12727    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12728    void getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
12729                                                   VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
12730                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12731#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12732    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12733    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
12734                         getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
12735                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12736    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12737    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12738                         getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
12739                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12740#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12741
12742    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12743    VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
12744                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
12745                                                                VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *                 pIndirectCommandsLayout,
12746                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12747#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12748    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12749    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type
12750      createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,
12751                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12752                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12753#  ifndef VULKAN_HPP_NO_SMART_HANDLE
12754    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12755    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type
12756      createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,
12757                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12758                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12759#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12760#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12761
12762    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12763    void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
12764                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12765                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12766#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12767    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12768    void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12769                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12770                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12771#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12772
12773    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12774    void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
12775                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12776                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12777#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12778    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12779    void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV                      indirectCommandsLayout,
12780                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12781                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12782#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12783
12784    //=== VK_EXT_private_data ===
12785
12786    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12787    VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,
12788                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
12789                                                          VULKAN_HPP_NAMESPACE::PrivateDataSlot *                 pPrivateDataSlot,
12790                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12791#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12792    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12793    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type
12794      createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
12795                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12796                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12797#  ifndef VULKAN_HPP_NO_SMART_HANDLE
12798    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12799    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type
12800      createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
12801                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12802                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12803#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12804#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12805
12806    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12807    void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,
12808                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12809                                    Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12810#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12811    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12812    void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12813                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12814                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12815#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12816
12817#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12818    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12819    VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
12820                                                   uint64_t                              objectHandle,
12821                                                   VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12822                                                   uint64_t                              data,
12823                                                   Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12824#else
12825    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12826    typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
12827                                                            uint64_t                              objectHandle,
12828                                                            VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12829                                                            uint64_t                              data,
12830                                                            Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12831#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12832
12833    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12834    void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
12835                            uint64_t                              objectHandle,
12836                            VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12837                            uint64_t *                            pData,
12838                            Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12839#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12840    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12841    VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
12842                                                     uint64_t                              objectHandle,
12843                                                     VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12844                                                     Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12845#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12846
12847    //=== VK_KHR_video_encode_queue ===
12848
12849    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12850    VULKAN_HPP_NODISCARD Result
12851      getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
12852                                           VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR *  pFeedbackInfo,
12853                                           size_t *                                                             pDataSize,
12854                                           void *                                                               pData,
12855                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12856#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12857    template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12858    VULKAN_HPP_NODISCARD
12859      typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
12860      getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
12861                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12862    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
12863              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12864              typename B2                                                                               = Uint8_tAllocator,
12865              typename std::enable_if<std::is_same<typename B2::value_type, uint8_t>::value, int>::type = 0>
12866    VULKAN_HPP_NODISCARD
12867      typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
12868      getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
12869                                           Uint8_tAllocator &                                                   uint8_tAllocator,
12870                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12871    template <typename X,
12872              typename Y,
12873              typename... Z,
12874              typename Uint8_tAllocator = std::allocator<uint8_t>,
12875              typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12876    VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
12877      getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
12878                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12879    template <typename X,
12880              typename Y,
12881              typename... Z,
12882              typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
12883              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12884              typename B2                                                                               = Uint8_tAllocator,
12885              typename std::enable_if<std::is_same<typename B2::value_type, uint8_t>::value, int>::type = 0>
12886    VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
12887      getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
12888                                           Uint8_tAllocator &                                                   uint8_tAllocator,
12889                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12890#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12891
12892#if defined( VK_ENABLE_BETA_EXTENSIONS )
12893    //=== VK_NV_cuda_kernel_launch ===
12894
12895    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12896    VULKAN_HPP_NODISCARD Result createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV * pCreateInfo,
12897                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
12898                                                    VULKAN_HPP_NAMESPACE::CudaModuleNV *                 pModule,
12899                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12900#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12901    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12902    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaModuleNV>::type
12903      createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV &                createInfo,
12904                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12905                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12906#    ifndef VULKAN_HPP_NO_SMART_HANDLE
12907    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12908    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaModuleNV, Dispatch>>::type
12909      createCudaModuleNVUnique( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV &                createInfo,
12910                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12911                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12912#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
12913#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12914
12915    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12916    VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module,
12917                                                      size_t *                           pCacheSize,
12918                                                      void *                             pCacheData,
12919                                                      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12920#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12921    template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12922    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
12923      getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12924    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
12925              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12926              typename B1                                                                               = Uint8_tAllocator,
12927              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
12928    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getCudaModuleCacheNV(
12929      VULKAN_HPP_NAMESPACE::CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12930#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12931
12932    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12933    VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV * pCreateInfo,
12934                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
12935                                                      VULKAN_HPP_NAMESPACE::CudaFunctionNV *                 pFunction,
12936                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12937#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12938    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12939    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>::type
12940      createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV &              createInfo,
12941                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12942                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12943#    ifndef VULKAN_HPP_NO_SMART_HANDLE
12944    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12945    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaFunctionNV, Dispatch>>::type
12946      createCudaFunctionNVUnique( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV &              createInfo,
12947                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12948                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12949#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
12950#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12951
12952    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12953    void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV                module,
12954                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12955                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12956#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12957    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12958    void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV                                  module,
12959                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12960                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12961#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12962
12963    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12964    void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV                module,
12965                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12966                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12967#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12968    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12969    void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV                                  module,
12970                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12971                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12972#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12973
12974    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12975    void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV              function,
12976                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12977                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12978#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12979    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12980    void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV                                function,
12981                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12982                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12983#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12984
12985    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12986    void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV              function,
12987                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12988                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12989#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12990    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12991    void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV                                function,
12992                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12993                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12994#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12995#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
12996
12997#if defined( VK_USE_PLATFORM_METAL_EXT )
12998    //=== VK_EXT_metal_objects ===
12999
13000    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13001    void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo,
13002                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13003#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13004    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13005    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT
13006                         exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13007    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13008    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13009                         exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13010#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13011#endif   /*VK_USE_PLATFORM_METAL_EXT*/
13012
13013    //=== VK_EXT_descriptor_buffer ===
13014
13015    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13016    void getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13017                                        VULKAN_HPP_NAMESPACE::DeviceSize *        pLayoutSizeInBytes,
13018                                        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13019#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13020    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13021    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
13022                         getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13023                                                        Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13024#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13025
13026    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13027    void getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13028                                                 uint32_t                                  binding,
13029                                                 VULKAN_HPP_NAMESPACE::DeviceSize *        pOffset,
13030                                                 Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13031#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13032    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13033    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
13034                         getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13035                                                                 uint32_t                                  binding,
13036                                                                 Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13037#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13038
13039    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13040    void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo,
13041                           size_t                                             dataSize,
13042                           void *                                             pDescriptor,
13043                           Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13044#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13045    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13046    void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
13047                           size_t                                             dataSize,
13048                           void *                                             pDescriptor,
13049                           Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13050    template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13051    VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
13052                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13053#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13054
13055    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13056    VULKAN_HPP_NODISCARD Result
13057      getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo,
13058                                               void *                                                           pData,
13059                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13060#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13061    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13062    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13063      getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info,
13064                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13065#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13066
13067    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13068    VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo,
13069                                                                        void *                                                          pData,
13070                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13071#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13072    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13073    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13074      getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info,
13075                                              Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13076#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13077
13078    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13079    VULKAN_HPP_NODISCARD Result
13080      getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo,
13081                                                  void *                                                              pData,
13082                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13083#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13084    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13085    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13086      getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info,
13087                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13088#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13089
13090    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13091    VULKAN_HPP_NODISCARD Result
13092      getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo,
13093                                                void *                                                            pData,
13094                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13095#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13096    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13097    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13098      getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info,
13099                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13100#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13101
13102    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13103    VULKAN_HPP_NODISCARD Result
13104      getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
13105                                                              void *                                                                          pData,
13106                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13107#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13108    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13109    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13110      getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info,
13111                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13112#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13113
13114    //=== VK_EXT_device_fault ===
13115
13116    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13117    VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts,
13118                                                 VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT *   pFaultInfo,
13119                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13120#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13121    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13122    VULKAN_HPP_NODISCARD ResultValue<std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>
13123                         getFaultInfoEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13124#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13125
13126#if defined( VK_USE_PLATFORM_FUCHSIA )
13127    //=== VK_FUCHSIA_external_memory ===
13128
13129    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13130    VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
13131                                                              zx_handle_t *                                                  pZirconHandle,
13132                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13133#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13134    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13135    VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
13136      getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
13137                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13138#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13139
13140    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13141    VULKAN_HPP_NODISCARD Result
13142      getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
13143                                              zx_handle_t                                                 zirconHandle,
13144                                              VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
13145                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13146#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13147    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13148    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
13149      getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
13150                                              zx_handle_t                                            zirconHandle,
13151                                              Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13152#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13153#endif   /*VK_USE_PLATFORM_FUCHSIA*/
13154
13155#if defined( VK_USE_PLATFORM_FUCHSIA )
13156    //=== VK_FUCHSIA_external_semaphore ===
13157
13158    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13159    VULKAN_HPP_NODISCARD Result
13160      importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
13161                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13162#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13163    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13164    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13165      importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
13166                                          Dispatch const & d                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13167#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13168
13169    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13170    VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
13171                                                                 zx_handle_t *                                                     pZirconHandle,
13172                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13173#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13174    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13175    VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
13176      getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
13177                                       Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13178#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13179#endif   /*VK_USE_PLATFORM_FUCHSIA*/
13180
13181#if defined( VK_USE_PLATFORM_FUCHSIA )
13182    //=== VK_FUCHSIA_buffer_collection ===
13183
13184    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13185    VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
13186                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
13187                                                               VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA *                 pCollection,
13188                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13189#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13190    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13191    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type
13192      createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,
13193                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13194                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13195#    ifndef VULKAN_HPP_NO_SMART_HANDLE
13196    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13197    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type
13198      createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,
13199                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13200                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13201#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
13202#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13203
13204    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13205    VULKAN_HPP_NODISCARD Result
13206      setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
13207                                                  const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
13208                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13209#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13210    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13211    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13212      setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
13213                                                  const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,
13214                                                  Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13215#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13216
13217    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13218    VULKAN_HPP_NODISCARD Result
13219      setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
13220                                                   const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,
13221                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13222#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13223    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13224    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13225      setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
13226                                                   const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,
13227                                                   Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13228#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13229
13230    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13231    void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
13232                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13233                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13234#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13235    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13236    void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,
13237                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13238                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13239#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13240
13241    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13242    void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
13243                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13244                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13245#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13246    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13247    void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,
13248                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13249                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13250#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13251
13252    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13253    VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
13254                                                                      VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties,
13255                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13256#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13257    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13258    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type
13259      getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13260                                            Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13261#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13262#endif   /*VK_USE_PLATFORM_FUCHSIA*/
13263
13264    //=== VK_HUAWEI_subpass_shading ===
13265
13266    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13267    VULKAN_HPP_NODISCARD Result
13268      getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,
13269                                               VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,
13270                                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13271#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13272    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13273    VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Extent2D>
13274      getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13275#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13276
13277    //=== VK_NV_external_memory_rdma ===
13278
13279    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13280    VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
13281                                                          VULKAN_HPP_NAMESPACE::RemoteAddressNV *                    pAddress,
13282                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13283#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13284    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13285    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type
13286      getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,
13287                                Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13288#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13289
13290    //=== VK_EXT_pipeline_properties ===
13291
13292    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13293    VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT * pPipelineInfo,
13294                                                          VULKAN_HPP_NAMESPACE::BaseOutStructure *      pPipelineProperties,
13295                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13296#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13297    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13298    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BaseOutStructure>::type
13299      getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13300#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13301
13302    //=== VK_EXT_opacity_micromap ===
13303
13304    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13305    VULKAN_HPP_NODISCARD Result createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo,
13306                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
13307                                                   VULKAN_HPP_NAMESPACE::MicromapEXT *                 pMicromap,
13308                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13309#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13310    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13311    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MicromapEXT>::type
13312      createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,
13313                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13314                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13315#  ifndef VULKAN_HPP_NO_SMART_HANDLE
13316    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13317    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>>::type
13318      createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,
13319                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13320                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13321#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13322#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13323
13324    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13325    void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,
13326                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13327                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13328#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13329    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13330    void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap                          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13331                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13332                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13333#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13334
13335    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13336    void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,
13337                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13338                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13339#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13340    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13341    void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                                   micromap,
13342                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13343                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13344#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13345
13346    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13347    VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR         deferredOperation,
13348                                                   uint32_t                                           infoCount,
13349                                                   const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,
13350                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13351#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13352    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13353    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
13354                         buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                 deferredOperation,
13355                                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,
13356                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13357#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13358
13359    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13360    VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,
13361                                                 const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,
13362                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13363#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13364    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13365    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,
13366                                                                       const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,
13367                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13368#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13369
13370    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13371    VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
13372                                                         const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,
13373                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13374#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13375    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13376    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
13377                                                                               const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,
13378                                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13379#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13380
13381    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13382    VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
13383                                                         const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,
13384                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13385#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13386    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13387    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
13388                                                                               const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,
13389                                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13390#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13391
13392    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13393    VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,
13394                                                             const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
13395                                                             VULKAN_HPP_NAMESPACE::QueryType           queryType,
13396                                                             size_t                                    dataSize,
13397                                                             void *                                    pData,
13398                                                             size_t                                    stride,
13399                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13400#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13401    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13402    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
13403      writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
13404                                   VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,
13405                                   size_t                                                                            dataSize,
13406                                   size_t                                                                            stride,
13407                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13408    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13409    VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13410      writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
13411                                 VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,
13412                                 size_t                                                                            stride,
13413                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13414#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13415
13416    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13417    void getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT *          pVersionInfo,
13418                                      VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility,
13419                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13420#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13421    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13422    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
13423                         getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo,
13424                                                      Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13425#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13426
13427    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13428    void getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
13429                                   const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *      pBuildInfo,
13430                                   VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT *       pSizeInfo,
13431                                   Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13432#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13433    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13434    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT
13435                         getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
13436                                                   const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT &      buildInfo,
13437                                                   Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13438#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13439
13440    //=== VK_EXT_pageable_device_local_memory ===
13441
13442    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13443    void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
13444                               float                              priority,
13445                               Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13446
13447    //=== VK_KHR_maintenance4 ===
13448
13449    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13450    void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,
13451                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                  pMemoryRequirements,
13452                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13453#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13454    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13455    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
13456                         getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
13457                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13458    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13459    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13460                         getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
13461                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13462#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13463
13464    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13465    void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
13466                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
13467                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13468#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13469    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13470    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
13471                         getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
13472                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13473    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13474    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13475                         getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
13476                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13477#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13478
13479    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13480    void getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
13481                                              uint32_t *                                                  pSparseMemoryRequirementCount,
13482                                              VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *      pSparseMemoryRequirements,
13483                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13484#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13485    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
13486              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13487    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
13488                         getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
13489                                                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13490    template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
13491              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13492              typename B1                                      = SparseImageMemoryRequirements2Allocator,
13493              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value, int>::type = 0>
13494    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
13495                         getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
13496                                                              SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
13497                                                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13498#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13499
13500    //=== VK_VALVE_descriptor_set_host_mapping ===
13501
13502    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13503    void getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference,
13504                                                     VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE *  pHostMapping,
13505                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13506#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13507    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13508    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE
13509                         getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference,
13510                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13511#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13512
13513    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13514    void getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
13515                                           void **                             ppData,
13516                                           Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13517#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13518    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13519    VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
13520                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13521#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13522
13523    //=== VK_NV_device_generated_commands_compute ===
13524
13525    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13526    void getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfo,
13527                                                  VULKAN_HPP_NAMESPACE::MemoryRequirements2 *             pMemoryRequirements,
13528                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13529#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13530    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13531    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
13532                         getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
13533                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13534    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13535    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13536                         getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
13537                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13538#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13539
13540    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13541    DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV * pInfo,
13542                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13543#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13544    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13545    VULKAN_HPP_NAMESPACE::DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info,
13546                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13547#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13548
13549    //=== VK_EXT_shader_module_identifier ===
13550
13551    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13552    void getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
13553                                       VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier,
13554                                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13555#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13556    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13557    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
13558                         getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
13559                                                       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13560#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13561
13562    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13563    void getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
13564                                                 VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT *    pIdentifier,
13565                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13566#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13567    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13568    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
13569                         getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
13570                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13571#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13572
13573    //=== VK_NV_optical_flow ===
13574
13575    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13576    VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo,
13577                                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
13578                                                            VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV *                 pSession,
13579                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13580#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13581    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13582    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>::type
13583      createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,
13584                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13585                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13586#  ifndef VULKAN_HPP_NO_SMART_HANDLE
13587    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13588    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>>::type
13589      createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,
13590                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13591                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13592#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13593#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13594
13595    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13596    void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,
13597                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13598                                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13599#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13600    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13601    void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,
13602                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13603                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13604#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13605
13606    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13607    void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,
13608                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13609                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13610#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13611    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13612    void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,
13613                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13614                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13615#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13616
13617#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13618    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13619    VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
13620                                                               VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
13621                                                               VULKAN_HPP_NAMESPACE::ImageView                        view,
13622                                                               VULKAN_HPP_NAMESPACE::ImageLayout                      layout,
13623                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13624#else
13625    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13626    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13627         bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
13628                                        VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
13629                                        VULKAN_HPP_NAMESPACE::ImageView                        view,
13630                                        VULKAN_HPP_NAMESPACE::ImageLayout                      layout,
13631                                        Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13632#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13633
13634    //=== VK_KHR_maintenance5 ===
13635
13636    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13637    void getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR * pRenderingAreaInfo,
13638                                         VULKAN_HPP_NAMESPACE::Extent2D *                   pGranularity,
13639                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13640#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13641    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13642    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
13643                         getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR & renderingAreaInfo,
13644                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13645#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13646
13647    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13648    void getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR * pInfo,
13649                                       VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR *               pLayout,
13650                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13651#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13652    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13653    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
13654                         getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info,
13655                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13656    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13657    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13658                         getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info,
13659                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13660#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13661
13662    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13663    void getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                        image,
13664                                        const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource,
13665                                        VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR *      pLayout,
13666                                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13667#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13668    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13669    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
13670                         getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                        image,
13671                                                        const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
13672                                                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13673    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13674    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13675                         getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                        image,
13676                                                        const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
13677                                                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13678#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13679
13680    //=== VK_EXT_shader_object ===
13681
13682    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13683    VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t                                          createInfoCount,
13684                                                  const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos,
13685                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13686                                                  VULKAN_HPP_NAMESPACE::ShaderEXT *                 pShaders,
13687                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13688#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13689    template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13690    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>::type
13691      createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
13692                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13693                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13694    template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>,
13695              typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13696              typename B0                 = ShaderEXTAllocator,
13697              typename std::enable_if<std::is_same<typename B0::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type = 0>
13698    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>::type
13699      createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
13700                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,
13701                        ShaderEXTAllocator &                                                                      shaderEXTAllocator,
13702                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13703    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13704    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderEXT>::type
13705      createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT &                   createInfo,
13706                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13707                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13708#  ifndef VULKAN_HPP_NO_SMART_HANDLE
13709    template <typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13710              typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>>
13711    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>::type
13712      createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
13713                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13714                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13715    template <typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13716              typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>,
13717              typename B0                 = ShaderEXTAllocator,
13718              typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value, int>::type = 0>
13719    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>::type
13720      createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
13721                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,
13722                              ShaderEXTAllocator &                                                                      shaderEXTAllocator,
13723                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13724    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13725    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::type
13726      createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT &                   createInfo,
13727                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13728                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13729#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13730#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13731
13732    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13733    void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT                   shader,
13734                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13735                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13736#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13737    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13738    void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT                                     shader,
13739                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13740                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13741#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13742
13743    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13744    void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT                   shader,
13745                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13746                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13747#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13748    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13749    void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT                                     shader,
13750                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13751                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13752#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13753
13754    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13755    VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader,
13756                                                        size_t *                        pDataSize,
13757                                                        void *                          pData,
13758                                                        Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13759#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13760    template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13761    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
13762      getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13763    template <typename Uint8_tAllocator                                                                 = std::allocator<uint8_t>,
13764              typename Dispatch                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13765              typename B1                                                                               = Uint8_tAllocator,
13766              typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
13767    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderBinaryDataEXT(
13768      VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13769#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13770
13771    //=== VK_QCOM_tile_properties ===
13772
13773    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13774    VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer          framebuffer,
13775                                                                  uint32_t *                                 pPropertiesCount,
13776                                                                  VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties,
13777                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13778#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13779    template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
13780              typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13781    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
13782      getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13783    template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
13784              typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13785              typename B1                          = TilePropertiesQCOMAllocator,
13786              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type = 0>
13787    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
13788      getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
13789                                        TilePropertiesQCOMAllocator &     tilePropertiesQCOMAllocator,
13790                                        Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13791#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13792
13793    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13794    Result getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
13795                                                  VULKAN_HPP_NAMESPACE::TilePropertiesQCOM *  pProperties,
13796                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13797#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13798    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13799    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM
13800                         getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
13801                                                                Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13802#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13803
13804    //=== VK_NV_low_latency2 ===
13805
13806    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13807    VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
13808                                                       const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo,
13809                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13810#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13811    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13812    typename ResultValueType<void>::type setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
13813                                                                const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo,
13814                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13815#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13816
13817    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13818    VULKAN_HPP_NODISCARD Result latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR               swapchain,
13819                                                const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo,
13820                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13821#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13822    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13823    typename ResultValueType<void>::type latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR               swapchain,
13824                                                         const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo,
13825                                                         Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13826#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13827
13828    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13829    void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
13830                             const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
13831                             Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13832#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13833    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13834    void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
13835                             const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo,
13836                             Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13837#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13838
13839    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13840    void getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR             swapchain,
13841                              VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
13842                              Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13843#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13844    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13845    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV
13846                         getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13847                                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13848#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13849
13850#if defined( VK_USE_PLATFORM_SCREEN_QNX )
13851    //=== VK_QNX_external_memory_screen_buffer ===
13852
13853    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13854    VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer *                     buffer,
13855                                                              VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX * pProperties,
13856                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13857#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13858    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13859    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>::type
13860      getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13861    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13862    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
13863      getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13864#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13865#endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
13866
13867    //=== VK_KHR_calibrated_timestamps ===
13868
13869    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13870    VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t                                                 timestampCount,
13871                                                            const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
13872                                                            uint64_t *                                               pTimestamps,
13873                                                            uint64_t *                                               pMaxDeviation,
13874                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13875#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13876    template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13877    VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
13878      getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
13879                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13880    template <typename Uint64_tAllocator                                                                 = std::allocator<uint64_t>,
13881              typename Dispatch                                                                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13882              typename B0                                                                                = Uint64_tAllocator,
13883              typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type = 0>
13884    VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
13885      getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
13886                                  Uint64_tAllocator &                                                                              uint64_tAllocator,
13887                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13888    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13889    VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
13890      getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
13891                                 Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13892#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13893
13894    operator VkDevice() const VULKAN_HPP_NOEXCEPT
13895    {
13896      return m_device;
13897    }
13898
13899    explicit operator bool() const VULKAN_HPP_NOEXCEPT
13900    {
13901      return m_device != VK_NULL_HANDLE;
13902    }
13903
13904    bool operator!() const VULKAN_HPP_NOEXCEPT
13905    {
13906      return m_device == VK_NULL_HANDLE;
13907    }
13908
13909  private:
13910    VkDevice m_device = {};
13911  };
13912
13913  template <>
13914  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
13915  {
13916    using Type = VULKAN_HPP_NAMESPACE::Device;
13917  };
13918
13919  template <>
13920  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
13921  {
13922    using Type = VULKAN_HPP_NAMESPACE::Device;
13923  };
13924
13925  template <>
13926  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
13927  {
13928    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
13929  };
13930
13931  class DisplayModeKHR
13932  {
13933  public:
13934    using CType      = VkDisplayModeKHR;
13935    using NativeType = VkDisplayModeKHR;
13936
13937    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
13938    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
13939      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
13940
13941  public:
13942    VULKAN_HPP_CONSTEXPR DisplayModeKHR() = default;
13943
13944    VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
13945
13946    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}
13947
13948#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
13949    DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
13950    {
13951      m_displayModeKHR = displayModeKHR;
13952      return *this;
13953    }
13954#endif
13955
13956    DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
13957    {
13958      m_displayModeKHR = {};
13959      return *this;
13960    }
13961
13962#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
13963    auto operator<=>( DisplayModeKHR const & ) const = default;
13964#else
13965    bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
13966    {
13967      return m_displayModeKHR == rhs.m_displayModeKHR;
13968    }
13969
13970    bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
13971    {
13972      return m_displayModeKHR != rhs.m_displayModeKHR;
13973    }
13974
13975    bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
13976    {
13977      return m_displayModeKHR < rhs.m_displayModeKHR;
13978    }
13979#endif
13980
13981    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
13982    {
13983      return m_displayModeKHR;
13984    }
13985
13986    explicit operator bool() const VULKAN_HPP_NOEXCEPT
13987    {
13988      return m_displayModeKHR != VK_NULL_HANDLE;
13989    }
13990
13991    bool operator!() const VULKAN_HPP_NOEXCEPT
13992    {
13993      return m_displayModeKHR == VK_NULL_HANDLE;
13994    }
13995
13996  private:
13997    VkDisplayModeKHR m_displayModeKHR = {};
13998  };
13999
14000  template <>
14001  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
14002  {
14003    using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
14004  };
14005
14006  template <>
14007  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
14008  {
14009    using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
14010  };
14011
14012  template <>
14013  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
14014  {
14015    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
14016  };
14017
14018  class PhysicalDevice
14019  {
14020  public:
14021    using CType      = VkPhysicalDevice;
14022    using NativeType = VkPhysicalDevice;
14023
14024    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
14025    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
14026      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
14027
14028  public:
14029    VULKAN_HPP_CONSTEXPR PhysicalDevice() = default;
14030
14031    VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
14032
14033    PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}
14034
14035    PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
14036    {
14037      m_physicalDevice = physicalDevice;
14038      return *this;
14039    }
14040
14041    PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
14042    {
14043      m_physicalDevice = {};
14044      return *this;
14045    }
14046
14047#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
14048    auto operator<=>( PhysicalDevice const & ) const = default;
14049#else
14050    bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
14051    {
14052      return m_physicalDevice == rhs.m_physicalDevice;
14053    }
14054
14055    bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
14056    {
14057      return m_physicalDevice != rhs.m_physicalDevice;
14058    }
14059
14060    bool operator<( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
14061    {
14062      return m_physicalDevice < rhs.m_physicalDevice;
14063    }
14064#endif
14065
14066    //=== VK_VERSION_1_0 ===
14067
14068    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14069    void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
14070                      Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14071#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14072    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14073    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
14074                         getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14075#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14076
14077    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14078    void getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
14079                              VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
14080                              Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14081#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14082    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14083    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
14084      getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14085#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14086
14087    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14088    VULKAN_HPP_NODISCARD Result getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
14089                                                          VULKAN_HPP_NAMESPACE::ImageType               type,
14090                                                          VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
14091                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
14092                                                          VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
14093                                                          VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
14094                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14095#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14096    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14097    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
14098      getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                 format,
14099                                VULKAN_HPP_NAMESPACE::ImageType              type,
14100                                VULKAN_HPP_NAMESPACE::ImageTiling            tiling,
14101                                VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,
14102                                VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14103                                Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14104#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14105
14106    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14107    void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
14108                        Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14109#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14110    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14111    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
14112                         getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14113#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14114
14115    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14116    void getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
14117                                   VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
14118                                   Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14119#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14120    template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
14121              typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14122    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
14123                         getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14124    template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
14125              typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14126              typename B1                             = QueueFamilyPropertiesAllocator,
14127              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value, int>::type = 0>
14128    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
14129                         getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
14130                                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14131#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14132
14133    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14134    void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
14135                              Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14136#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14137    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14138    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
14139                         getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14140#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14141
14142    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14143    VULKAN_HPP_NODISCARD Result createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *    pCreateInfo,
14144                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14145                                              VULKAN_HPP_NAMESPACE::Device *                    pDevice,
14146                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14147#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14148    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14149    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
14150      createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &                      createInfo,
14151                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14152                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14153#  ifndef VULKAN_HPP_NO_SMART_HANDLE
14154    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14155    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
14156      createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &                      createInfo,
14157                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14158                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14159#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
14160#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14161
14162    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14163    VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char *                                pLayerName,
14164                                                                    uint32_t *                                  pPropertyCount,
14165                                                                    VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
14166                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14167#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14168    template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
14169              typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14170    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
14171      enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14172                                          Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14173    template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
14174              typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14175              typename B1                           = ExtensionPropertiesAllocator,
14176              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
14177    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
14178      enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
14179                                          ExtensionPropertiesAllocator & extensionPropertiesAllocator,
14180                                          Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14181#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14182
14183    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14184    VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t *                              pPropertyCount,
14185                                                                VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
14186                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14187#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14188    template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14189    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
14190      enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14191    template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
14192              typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14193              typename B1                       = LayerPropertiesAllocator,
14194              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
14195    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
14196      enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14197#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14198
14199    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14200    void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
14201                                         VULKAN_HPP_NAMESPACE::ImageType                     type,
14202                                         VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
14203                                         VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
14204                                         VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
14205                                         uint32_t *                                          pPropertyCount,
14206                                         VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
14207                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14208#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14209    template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
14210              typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14211    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
14212                         getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
14213                                                         VULKAN_HPP_NAMESPACE::ImageType           type,
14214                                                         VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
14215                                                         VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
14216                                                         VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
14217                                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14218    template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
14219              typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14220              typename B1                                   = SparseImageFormatPropertiesAllocator,
14221              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value, int>::type = 0>
14222    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
14223                         getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
14224                                                         VULKAN_HPP_NAMESPACE::ImageType           type,
14225                                                         VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
14226                                                         VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
14227                                                         VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
14228                                                         SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
14229                                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14230#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14231
14232    //=== VK_VERSION_1_1 ===
14233
14234    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14235    void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
14236                       Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14237#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14238    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14239    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
14240                         getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14241    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14242    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14243                         getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14244#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14245
14246    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14247    void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
14248                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14249#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14250    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14251    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
14252                         getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14253    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14254    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14255                         getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14256#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14257
14258    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14259    void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
14260                               VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
14261                               Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14262#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14263    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14264    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
14265      getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14266    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14267    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14268      getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14269#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14270
14271    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14272    VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
14273                                                           VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
14274                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14275#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14276    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14277    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
14278      getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14279                                 Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14280    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14281    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14282      getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14283                                 Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14284#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14285
14286    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14287    void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
14288                                    VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
14289                                    Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14290#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14291    template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14292              typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14293    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14294                         getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14295    template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14296              typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14297              typename B1                              = QueueFamilyProperties2Allocator,
14298              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type = 0>
14299    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14300                         getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
14301                                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14302    template <typename StructureChain,
14303              typename StructureChainAllocator = std::allocator<StructureChain>,
14304              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14305    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14306                         getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14307    template <typename StructureChain,
14308              typename StructureChainAllocator                                                                 = std::allocator<StructureChain>,
14309              typename Dispatch                                                                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14310              typename B1                                                                                      = StructureChainAllocator,
14311              typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
14312    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14313      getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14314#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14315
14316    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14317    void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
14318                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14319#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14320    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14321    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
14322                         getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14323    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14324    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14325                         getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14326#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14327
14328    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14329    void getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
14330                                          uint32_t *                                                         pPropertyCount,
14331                                          VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
14332                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14333#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14334    template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14335              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14336    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14337                         getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14338                                                          Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14339    template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14340              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14341              typename B1                                    = SparseImageFormatProperties2Allocator,
14342              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value, int>::type = 0>
14343    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14344                         getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14345                                                          SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,
14346                                                          Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14347#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14348
14349    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14350    void getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
14351                                      VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
14352                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14353#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14354    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14355    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
14356                         getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
14357                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14358#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14359
14360    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14361    void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
14362                                     VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
14363                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14364#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14365    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14366    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
14367                         getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
14368                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14369#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14370
14371    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14372    void getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
14373                                         VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
14374                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14375#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14376    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14377    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
14378                         getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
14379                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14380#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14381
14382    //=== VK_VERSION_1_3 ===
14383
14384    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14385    VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t *                                           pToolCount,
14386                                                   VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,
14387                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14388#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14389    template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
14390              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14391    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
14392      getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14393    template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
14394              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14395              typename B1                                    = PhysicalDeviceToolPropertiesAllocator,
14396              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value, int>::type = 0>
14397    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
14398      getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
14399                         Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14400#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14401
14402    //=== VK_KHR_surface ===
14403
14404    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14405    VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
14406                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14407                                                      VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
14408                                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14409#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14410    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14411    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type getSurfaceSupportKHR(
14412      uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14413#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14414
14415    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14416    VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
14417                                                           VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
14418                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14419#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14420    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14421    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
14422      getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14423#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14424
14425    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14426    VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
14427                                                      uint32_t *                               pSurfaceFormatCount,
14428                                                      VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
14429                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14430#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14431    template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
14432              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14433    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
14434      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14435                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14436    template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
14437              typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14438              typename B1                        = SurfaceFormatKHRAllocator,
14439              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type = 0>
14440    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
14441      getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14442                            SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
14443                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14444#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14445
14446    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14447    VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
14448                                                           uint32_t *                             pPresentModeCount,
14449                                                           VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
14450                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14451#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14452    template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14453    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
14454      getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14455                                 Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14456    template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
14457              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14458              typename B1                      = PresentModeKHRAllocator,
14459              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
14460    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
14461      getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14462                                 PresentModeKHRAllocator &        presentModeKHRAllocator,
14463                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14464#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14465
14466    //=== VK_KHR_swapchain ===
14467
14468    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14469    VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14470                                                         uint32_t *                       pRectCount,
14471                                                         VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
14472                                                         Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14473#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14474    template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14475    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type
14476      getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14477    template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>,
14478              typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14479              typename B1              = Rect2DAllocator,
14480              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type = 0>
14481    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR(
14482      VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14483#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14484
14485    //=== VK_KHR_display ===
14486
14487    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14488    VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
14489                                                         VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
14490                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14491#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14492    template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
14493              typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14494    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
14495      getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14496    template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
14497              typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14498              typename B1                            = DisplayPropertiesKHRAllocator,
14499              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value, int>::type = 0>
14500    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
14501      getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
14502                               Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14503#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14504
14505    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14506    VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t *                                        pPropertyCount,
14507                                                              VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
14508                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14509#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14510    template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
14511              typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14512    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
14513      getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14514    template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
14515              typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14516              typename B1                                 = DisplayPlanePropertiesKHRAllocator,
14517              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value, int>::type = 0>
14518    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
14519      getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
14520                                    Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14521#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14522
14523    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14524    VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t                           planeIndex,
14525                                                                     uint32_t *                         pDisplayCount,
14526                                                                     VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
14527                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14528#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14529    template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14530    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type
14531      getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14532    template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>,
14533              typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14534              typename B1                  = DisplayKHRAllocator,
14535              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type = 0>
14536    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR(
14537      uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14538#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14539
14540    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14541    VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
14542                                                             uint32_t *                                       pPropertyCount,
14543                                                             VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
14544                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14545#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14546    template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
14547              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14548    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
14549      getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14550    template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
14551              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14552              typename B1                                = DisplayModePropertiesKHRAllocator,
14553              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value, int>::type = 0>
14554    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
14555      getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
14556                                   DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
14557                                   Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14558#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14559
14560    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14561    VULKAN_HPP_NODISCARD Result createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
14562                                                      const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
14563                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
14564                                                      VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
14565                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14566#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14567    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14568    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
14569      createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
14570                            const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &              createInfo,
14571                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14572                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14573#  ifndef VULKAN_HPP_NO_SMART_HANDLE
14574    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14575    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
14576      createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
14577                                  const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &              createInfo,
14578                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14579                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14580#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
14581#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14582
14583    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14584    VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
14585                                                                uint32_t                                            planeIndex,
14586                                                                VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
14587                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14588#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14589    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14590    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR(
14591      VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14592#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14593
14594#if defined( VK_USE_PLATFORM_XLIB_KHR )
14595    //=== VK_KHR_xlib_surface ===
14596
14597    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14598    Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
14599                                          Display *          dpy,
14600                                          VisualID           visualID,
14601                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14602#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14603    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14604    VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
14605                                                                Display &          dpy,
14606                                                                VisualID           visualID,
14607                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14608#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14609#endif   /*VK_USE_PLATFORM_XLIB_KHR*/
14610
14611#if defined( VK_USE_PLATFORM_XCB_KHR )
14612    //=== VK_KHR_xcb_surface ===
14613
14614    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14615    Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
14616                                         xcb_connection_t * connection,
14617                                         xcb_visualid_t     visual_id,
14618                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14619#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14620    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14621    VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
14622                                                               xcb_connection_t & connection,
14623                                                               xcb_visualid_t     visual_id,
14624                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14625#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14626#endif   /*VK_USE_PLATFORM_XCB_KHR*/
14627
14628#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
14629    //=== VK_KHR_wayland_surface ===
14630
14631    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14632    Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
14633                                             struct wl_display * display,
14634                                             Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14635#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14636    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14637    VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
14638                                                                   struct wl_display & display,
14639                                                                   Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14640#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14641#endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
14642
14643#if defined( VK_USE_PLATFORM_WIN32_KHR )
14644    //=== VK_KHR_win32_surface ===
14645
14646    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14647    Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14648#endif /*VK_USE_PLATFORM_WIN32_KHR*/
14649
14650    //=== VK_KHR_video_queue ===
14651
14652    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14653    VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile,
14654                                                         VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *      pCapabilities,
14655                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14656#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14657    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14658    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
14659      getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
14660                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14661    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14662    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14663      getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
14664                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14665#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14666
14667    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14668    VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
14669                                                             uint32_t *                                                     pVideoFormatPropertyCount,
14670                                                             VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
14671                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14672#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14673    template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
14674              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14675    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
14676      getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
14677                                   Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14678    template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
14679              typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14680              typename B1                                = VideoFormatPropertiesKHRAllocator,
14681              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value, int>::type = 0>
14682    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
14683      getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
14684                                   VideoFormatPropertiesKHRAllocator &                            videoFormatPropertiesKHRAllocator,
14685                                   Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14686#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14687
14688    //=== VK_NV_external_memory_capabilities ===
14689
14690    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14691    VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                            format,
14692                                                                    VULKAN_HPP_NAMESPACE::ImageType                         type,
14693                                                                    VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
14694                                                                    VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
14695                                                                    VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
14696                                                                    VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
14697                                                                    VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
14698                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14699#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14700    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14701    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
14702      getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                                             format,
14703                                          VULKAN_HPP_NAMESPACE::ImageType                                          type,
14704                                          VULKAN_HPP_NAMESPACE::ImageTiling                                        tiling,
14705                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags                                    usage,
14706                                          VULKAN_HPP_NAMESPACE::ImageCreateFlags flags                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14707                                          VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14708                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14709#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14710
14711    //=== VK_KHR_get_physical_device_properties2 ===
14712
14713    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14714    void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
14715                          Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14716#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14717    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14718    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
14719                         getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14720    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14721    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14722                         getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14723#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14724
14725    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14726    void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
14727                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14728#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14729    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14730    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
14731                         getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14732    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14733    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14734                         getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14735#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14736
14737    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14738    void getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
14739                                  VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
14740                                  Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14741#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14742    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14743    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
14744      getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14745    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14746    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14747      getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14748#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14749
14750    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14751    VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
14752                                                              VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
14753                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14754#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14755    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14756    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
14757      getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14758                                    Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14759    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14760    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14761      getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14762                                    Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14763#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14764
14765    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14766    void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,
14767                                       VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
14768                                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14769#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14770    template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14771              typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14772    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14773                         getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14774    template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14775              typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14776              typename B1                              = QueueFamilyProperties2Allocator,
14777              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value, int>::type = 0>
14778    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14779                         getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
14780                                                       Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14781    template <typename StructureChain,
14782              typename StructureChainAllocator = std::allocator<StructureChain>,
14783              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14784    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14785                         getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14786    template <typename StructureChain,
14787              typename StructureChainAllocator                                                                 = std::allocator<StructureChain>,
14788              typename Dispatch                                                                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14789              typename B1                                                                                      = StructureChainAllocator,
14790              typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
14791    VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14792      getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14793#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14794
14795    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14796    void getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
14797                                  Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14798#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14799    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14800    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
14801                         getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14802    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14803    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14804                         getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14805#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14806
14807    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14808    void getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
14809                                             uint32_t *                                                         pPropertyCount,
14810                                             VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
14811                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14812#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14813    template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14814              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14815    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14816                         getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14817                                                             Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14818    template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14819              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14820              typename B1                                    = SparseImageFormatProperties2Allocator,
14821              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value, int>::type = 0>
14822    VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14823                         getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14824                                                             SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,
14825                                                             Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14826#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14827
14828    //=== VK_KHR_external_memory_capabilities ===
14829
14830    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14831    void getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
14832                                         VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
14833                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14834#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14835    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14836    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
14837                         getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
14838                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14839#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14840
14841    //=== VK_KHR_external_semaphore_capabilities ===
14842
14843    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14844    void getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
14845                                            VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
14846                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14847#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14848    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14849    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
14850                         getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
14851                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14852#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14853
14854    //=== VK_EXT_direct_mode_display ===
14855
14856#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14857    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14858    Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14859#else
14860    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14861    void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14862#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14863
14864#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
14865    //=== VK_EXT_acquire_xlib_display ===
14866
14867    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14868    VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display *                        dpy,
14869                                                       VULKAN_HPP_NAMESPACE::DisplayKHR display,
14870                                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14871#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14872    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14873    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14874      acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14875#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14876
14877    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14878    VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display *                          dpy,
14879                                                          RROutput                           rrOutput,
14880                                                          VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
14881                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14882#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14883    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14884    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
14885      getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14886#    ifndef VULKAN_HPP_NO_SMART_HANDLE
14887    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14888    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
14889      getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14890#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
14891#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14892#endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
14893
14894    //=== VK_EXT_display_surface_counter ===
14895
14896    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14897    VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
14898                                                            VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
14899                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14900#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14901    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14902    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
14903      getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14904#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14905
14906    //=== VK_KHR_external_fence_capabilities ===
14907
14908    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14909    void getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
14910                                        VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
14911                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14912#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14913    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14914    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
14915                         getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
14916                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14917#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14918
14919    //=== VK_KHR_performance_query ===
14920
14921    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14922    VULKAN_HPP_NODISCARD Result
14923      enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t                                                 queueFamilyIndex,
14924                                                       uint32_t *                                               pCounterCount,
14925                                                       VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *            pCounters,
14926                                                       VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
14927                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14928#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14929    template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
14930              typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
14931              typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14932    VULKAN_HPP_NODISCARD
14933      typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
14934                                         std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
14935      enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14936    template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
14937              typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
14938              typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14939              typename B1                                        = PerformanceCounterKHRAllocator,
14940              typename B2                                        = PerformanceCounterDescriptionKHRAllocator,
14941              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value &&
14942                                        std::is_same<typename B2::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value,
14943                                      int>::type                 = 0>
14944    VULKAN_HPP_NODISCARD
14945      typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
14946                                         std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
14947      enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t                                    queueFamilyIndex,
14948                                                       PerformanceCounterKHRAllocator &            performanceCounterKHRAllocator,
14949                                                       PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
14950                                                       Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14951#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14952
14953    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14954    void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
14955                                                  uint32_t *                                                      pNumPasses,
14956                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14957#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14958    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14959    VULKAN_HPP_NODISCARD uint32_t
14960      getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
14961                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14962#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14963
14964    //=== VK_KHR_get_surface_capabilities2 ===
14965
14966    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14967    VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
14968                                                            VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
14969                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14970#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14971    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14972    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
14973      getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14974                                  Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14975    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14976    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14977      getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14978                                  Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14979#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14980
14981    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14982    VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
14983                                                       uint32_t *                                                  pSurfaceFormatCount,
14984                                                       VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *                   pSurfaceFormats,
14985                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14986#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14987    template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
14988              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14989    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
14990      getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14991                             Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14992    template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
14993              typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14994              typename B1                         = SurfaceFormat2KHRAllocator,
14995              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type = 0>
14996    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
14997      getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14998                             SurfaceFormat2KHRAllocator &                                surfaceFormat2KHRAllocator,
14999                             Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15000    template <typename StructureChain,
15001              typename StructureChainAllocator = std::allocator<StructureChain>,
15002              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15003    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
15004      getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15005                             Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15006    template <typename StructureChain,
15007              typename StructureChainAllocator                                                                 = std::allocator<StructureChain>,
15008              typename Dispatch                                                                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15009              typename B1                                                                                      = StructureChainAllocator,
15010              typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
15011    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
15012      getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15013                             StructureChainAllocator &                                   structureChainAllocator,
15014                             Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15015#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15016
15017    //=== VK_KHR_get_display_properties2 ===
15018
15019    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15020    VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
15021                                                          VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
15022                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15023#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15024    template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
15025              typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15026    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
15027      getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15028    template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
15029              typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15030              typename B1                             = DisplayProperties2KHRAllocator,
15031              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value, int>::type = 0>
15032    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
15033      getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
15034                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15035#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15036
15037    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15038    VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t *                                         pPropertyCount,
15039                                                               VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
15040                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15041#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15042    template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
15043              typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15044    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
15045      getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15046    template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
15047              typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15048              typename B1                                  = DisplayPlaneProperties2KHRAllocator,
15049              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value, int>::type = 0>
15050    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
15051      getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
15052                                     Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15053#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15054
15055    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15056    VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
15057                                                              uint32_t *                                        pPropertyCount,
15058                                                              VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
15059                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15060#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15061    template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
15062              typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15063    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
15064      getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15065    template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
15066              typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15067              typename B1                                 = DisplayModeProperties2KHRAllocator,
15068              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value, int>::type = 0>
15069    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
15070      getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR     display,
15071                                    DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
15072                                    Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15073#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15074
15075    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15076    VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
15077                                                                 VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
15078                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15079#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15080    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15081    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type
15082      getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo,
15083                                       Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15084#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15085
15086    //=== VK_EXT_sample_locations ===
15087
15088    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15089    void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
15090                                      VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
15091                                      Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15092#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15093    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15094    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
15095                         getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
15096                                                      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15097#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15098
15099    //=== VK_EXT_calibrated_timestamps ===
15100
15101    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15102    VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t *                            pTimeDomainCount,
15103                                                                VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
15104                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15105#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15106    template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15107    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
15108      getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15109    template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
15110              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15111              typename B1                     = TimeDomainKHRAllocator,
15112              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
15113    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
15114      getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15115#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15116
15117    //=== VK_KHR_fragment_shading_rate ===
15118
15119    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15120    VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t *                                                   pFragmentShadingRateCount,
15121                                                            VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
15122                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15123#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15124    template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
15125              typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15126    VULKAN_HPP_NODISCARD
15127      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
15128      getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15129    template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
15130              typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15131              typename B1                                            = PhysicalDeviceFragmentShadingRateKHRAllocator,
15132              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value, int>::type = 0>
15133    VULKAN_HPP_NODISCARD
15134      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
15135      getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
15136                                  Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15137#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15138
15139    //=== VK_EXT_tooling_info ===
15140
15141    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15142    VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t *                                           pToolCount,
15143                                                      VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,
15144                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15145#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15146    template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
15147              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15148    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
15149      getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15150    template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
15151              typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15152              typename B1                                    = PhysicalDeviceToolPropertiesAllocator,
15153              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value, int>::type = 0>
15154    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
15155      getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
15156                            Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15157#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15158
15159    //=== VK_NV_cooperative_matrix ===
15160
15161    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15162    VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t *                                            pPropertyCount,
15163                                                                  VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
15164                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15165#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15166    template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
15167              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15168    VULKAN_HPP_NODISCARD
15169      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
15170      getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15171    template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
15172              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15173              typename B1                                     = CooperativeMatrixPropertiesNVAllocator,
15174              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value, int>::type = 0>
15175    VULKAN_HPP_NODISCARD
15176      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
15177      getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
15178                                        Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15179#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15180
15181    //=== VK_NV_coverage_reduction_mode ===
15182
15183    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15184    VULKAN_HPP_NODISCARD Result
15185      getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t *                                                   pCombinationCount,
15186                                                         VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
15187                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15188#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15189    template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
15190              typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15191    VULKAN_HPP_NODISCARD
15192      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
15193      getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15194    template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
15195              typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15196              typename B1                                            = FramebufferMixedSamplesCombinationNVAllocator,
15197              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value, int>::type = 0>
15198    VULKAN_HPP_NODISCARD
15199      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
15200      getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
15201                                                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15202#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15203
15204#if defined( VK_USE_PLATFORM_WIN32_KHR )
15205    //=== VK_EXT_full_screen_exclusive ===
15206
15207    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15208    VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
15209                                                            uint32_t *                                                  pPresentModeCount,
15210                                                            VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,
15211                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15212#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15213    template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15214    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
15215      getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15216                                  Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15217    template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
15218              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15219              typename B1                      = PresentModeKHRAllocator,
15220              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
15221    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
15222      getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15223                                  PresentModeKHRAllocator &                                   presentModeKHRAllocator,
15224                                  Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15225#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15226#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
15227
15228    //=== VK_EXT_acquire_drm_display ===
15229
15230#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15231    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15232    VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t                          drmFd,
15233                                                      VULKAN_HPP_NAMESPACE::DisplayKHR display,
15234                                                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15235#else
15236    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15237    typename ResultValueType<void>::type
15238         acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15239#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15240
15241    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15242    VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t                            drmFd,
15243                                                  uint32_t                           connectorId,
15244                                                  VULKAN_HPP_NAMESPACE::DisplayKHR * display,
15245                                                  Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15246#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15247    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15248    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
15249      getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15250#  ifndef VULKAN_HPP_NO_SMART_HANDLE
15251    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15252    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
15253      getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15254#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15255#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15256
15257    //=== VK_KHR_video_encode_queue ===
15258
15259    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15260    VULKAN_HPP_NODISCARD Result
15261      getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
15262                                               VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR *               pQualityLevelProperties,
15263                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15264#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15265    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15266    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>::type
15267      getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
15268                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15269    template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15270    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
15271      getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
15272                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15273#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15274
15275#if defined( VK_USE_PLATFORM_WIN32_KHR )
15276    //=== VK_NV_acquire_winrt_display ===
15277
15278#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15279    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15280    VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
15281                                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15282#  else
15283    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15284    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15285      acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15286#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15287
15288    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15289    VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t                           deviceRelativeId,
15290                                                   VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
15291                                                   Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15292#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15293    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15294    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
15295      getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15296#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15297    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15298    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
15299      getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15300#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15301#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15302#endif     /*VK_USE_PLATFORM_WIN32_KHR*/
15303
15304#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
15305    //=== VK_EXT_directfb_surface ===
15306
15307    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15308    Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
15309                                              IDirectFB *        dfb,
15310                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15311#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15312    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15313    VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
15314                                                                    IDirectFB &        dfb,
15315                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15316#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15317#endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
15318
15319#if defined( VK_USE_PLATFORM_SCREEN_QNX )
15320    //=== VK_QNX_screen_surface ===
15321
15322    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15323    Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
15324                                            struct _screen_window * window,
15325                                            Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15326#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15327    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15328    VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
15329                                                                  struct _screen_window & window,
15330                                                                  Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15331#  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15332#endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
15333
15334    //=== VK_NV_optical_flow ===
15335
15336    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15337    VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
15338                                                              uint32_t *                                                 pFormatCount,
15339                                                              VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties,
15340                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15341#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15342    template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
15343              typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15344    VULKAN_HPP_NODISCARD
15345      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
15346      getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
15347                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15348    template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
15349              typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15350              typename B1                                          = OpticalFlowImageFormatPropertiesNVAllocator,
15351              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value, int>::type = 0>
15352    VULKAN_HPP_NODISCARD
15353      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
15354      getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
15355                                    OpticalFlowImageFormatPropertiesNVAllocator &              opticalFlowImageFormatPropertiesNVAllocator,
15356                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15357#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15358
15359    //=== VK_KHR_cooperative_matrix ===
15360
15361    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15362    VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t *                                             pPropertyCount,
15363                                                                   VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR * pProperties,
15364                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15365#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15366    template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,
15367              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15368    VULKAN_HPP_NODISCARD
15369      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
15370      getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15371    template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,
15372              typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15373              typename B1                                      = CooperativeMatrixPropertiesKHRAllocator,
15374              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value, int>::type = 0>
15375    VULKAN_HPP_NODISCARD
15376      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
15377      getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,
15378                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15379#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15380
15381    //=== VK_KHR_calibrated_timestamps ===
15382
15383    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15384    VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t *                            pTimeDomainCount,
15385                                                                VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
15386                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15387#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15388    template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15389    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
15390      getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15391    template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
15392              typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15393              typename B1                     = TimeDomainKHRAllocator,
15394              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
15395    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
15396      getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15397#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15398
15399    operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
15400    {
15401      return m_physicalDevice;
15402    }
15403
15404    explicit operator bool() const VULKAN_HPP_NOEXCEPT
15405    {
15406      return m_physicalDevice != VK_NULL_HANDLE;
15407    }
15408
15409    bool operator!() const VULKAN_HPP_NOEXCEPT
15410    {
15411      return m_physicalDevice == VK_NULL_HANDLE;
15412    }
15413
15414  private:
15415    VkPhysicalDevice m_physicalDevice = {};
15416  };
15417
15418  template <>
15419  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
15420  {
15421    using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
15422  };
15423
15424  template <>
15425  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
15426  {
15427    using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
15428  };
15429
15430  template <>
15431  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
15432  {
15433    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
15434  };
15435
15436  class Instance
15437  {
15438  public:
15439    using CType      = VkInstance;
15440    using NativeType = VkInstance;
15441
15442    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
15443    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
15444      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
15445
15446  public:
15447    VULKAN_HPP_CONSTEXPR Instance() = default;
15448
15449    VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
15450
15451    Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
15452
15453    Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
15454    {
15455      m_instance = instance;
15456      return *this;
15457    }
15458
15459    Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
15460    {
15461      m_instance = {};
15462      return *this;
15463    }
15464
15465#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
15466    auto operator<=>( Instance const & ) const = default;
15467#else
15468    bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
15469    {
15470      return m_instance == rhs.m_instance;
15471    }
15472
15473    bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
15474    {
15475      return m_instance != rhs.m_instance;
15476    }
15477
15478    bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
15479    {
15480      return m_instance < rhs.m_instance;
15481    }
15482#endif
15483
15484    //=== VK_VERSION_1_0 ===
15485
15486    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15487    void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15488                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15489#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15490    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15491    void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15492                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15493#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15494
15495    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15496    VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,
15497                                                          VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
15498                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15499#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15500    template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15501    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type
15502      enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15503    template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>,
15504              typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15505              typename B1                      = PhysicalDeviceAllocator,
15506              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type = 0>
15507    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type
15508      enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15509#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15510
15511    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15512    PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15513#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15514    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15515    PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15516#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15517
15518    //=== VK_VERSION_1_1 ===
15519
15520    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15521    VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t *                                            pPhysicalDeviceGroupCount,
15522                                                               VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
15523                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15524#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15525    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
15526              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15527    VULKAN_HPP_NODISCARD
15528      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
15529      enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15530    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
15531              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15532              typename B1                                     = PhysicalDeviceGroupPropertiesAllocator,
15533              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value, int>::type = 0>
15534    VULKAN_HPP_NODISCARD
15535      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
15536      enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
15537                                     Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15538#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15539
15540    //=== VK_KHR_surface ===
15541
15542    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15543    void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
15544                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15545                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15546#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15547    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15548    void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface                            VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15549                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15550                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15551#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15552
15553    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15554    void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
15555                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15556                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15557#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15558    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15559    void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                                    surface,
15560                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15561                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15562#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15563
15564    //=== VK_KHR_display ===
15565
15566    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15567    VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
15568                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
15569                                                              VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
15570                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15571#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15572    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15573    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15574      createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &           createInfo,
15575                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15576                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15577#  ifndef VULKAN_HPP_NO_SMART_HANDLE
15578    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15579    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15580      createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &           createInfo,
15581                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15582                                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15583#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15584#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15585
15586#if defined( VK_USE_PLATFORM_XLIB_KHR )
15587    //=== VK_KHR_xlib_surface ===
15588
15589    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15590    VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
15591                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
15592                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
15593                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15594#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15595    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15596    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15597      createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,
15598                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15599                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15600#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15601    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15602    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15603      createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,
15604                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15605                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15606#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15607#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15608#endif     /*VK_USE_PLATFORM_XLIB_KHR*/
15609
15610#if defined( VK_USE_PLATFORM_XCB_KHR )
15611    //=== VK_KHR_xcb_surface ===
15612
15613    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15614    VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
15615                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
15616                                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
15617                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15618#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15619    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15620    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15621      createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,
15622                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15623                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15624#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15625    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15626    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15627      createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,
15628                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15629                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15630#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15631#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15632#endif     /*VK_USE_PLATFORM_XCB_KHR*/
15633
15634#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
15635    //=== VK_KHR_wayland_surface ===
15636
15637    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15638    VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
15639                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
15640                                                         VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
15641                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15642#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15643    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15644    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15645      createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,
15646                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15647                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15648#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15649    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15650    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15651      createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,
15652                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15653                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15654#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15655#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15656#endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/
15657
15658#if defined( VK_USE_PLATFORM_ANDROID_KHR )
15659    //=== VK_KHR_android_surface ===
15660
15661    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15662    VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
15663                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
15664                                                         VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
15665                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15666#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15667    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15668    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15669      createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,
15670                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15671                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15672#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15673    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15674    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15675      createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,
15676                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15677                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15678#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15679#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15680#endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
15681
15682#if defined( VK_USE_PLATFORM_WIN32_KHR )
15683    //=== VK_KHR_win32_surface ===
15684
15685    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15686    VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
15687                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
15688                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
15689                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15690#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15691    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15692    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15693      createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,
15694                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15695                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15696#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15697    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15698    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15699      createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,
15700                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15701                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15702#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15703#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15704#endif     /*VK_USE_PLATFORM_WIN32_KHR*/
15705
15706#if defined( VK_USE_PLATFORM_OHOS )
15707    //=== VK_OHOS_surface ===
15708
15709    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15710    VULKAN_HPP_NODISCARD Result
15711      createSurfaceOHOS( const VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS * pCreateInfo,
15712                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
15713                                    VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
15714                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15715#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15716    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15717    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15718      createSurfaceOHOS( const VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS & createInfo,
15719                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
15720                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15721                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15722#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15723    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15724    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
15725      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15726      createSurfaceOHOSUnique( const VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS & createInfo,
15727                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
15728                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15729                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15730#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
15731#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15732#endif     /*VK_USE_PLATFORM_OHOS*/
15733
15734    //=== VK_EXT_debug_report ===
15735
15736    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15737    VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
15738                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
15739                                                              VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
15740                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15741#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15742    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15743    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type
15744      createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,
15745                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15746                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15747#  ifndef VULKAN_HPP_NO_SMART_HANDLE
15748    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15749    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
15750      createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,
15751                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15752                                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15753#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15754#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15755
15756    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15757    void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
15758                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15759                                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15760#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15761    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15762    void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15763                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15764                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15765#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15766
15767    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15768    void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
15769                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15770                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15771#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15772    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15773    void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT                        callback,
15774                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15775                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15776#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15777
15778    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15779    void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
15780                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
15781                                uint64_t                                       object,
15782                                size_t                                         location,
15783                                int32_t                                        messageCode,
15784                                const char *                                   pLayerPrefix,
15785                                const char *                                   pMessage,
15786                                Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15787#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15788    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15789    void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
15790                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
15791                                uint64_t                                       object,
15792                                size_t                                         location,
15793                                int32_t                                        messageCode,
15794                                const std::string &                            layerPrefix,
15795                                const std::string &                            message,
15796                                Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15797#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15798
15799#if defined( VK_USE_PLATFORM_GGP )
15800    //=== VK_GGP_stream_descriptor_surface ===
15801
15802    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15803    VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
15804                                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
15805                                                                  VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
15806                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15807#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15808    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15809    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15810      createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,
15811                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15812                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15813#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15814    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15815    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createStreamDescriptorSurfaceGGPUnique(
15816      const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,
15817      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15818      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15819#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15820#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15821#endif     /*VK_USE_PLATFORM_GGP*/
15822
15823#if defined( VK_USE_PLATFORM_VI_NN )
15824    //=== VK_NN_vi_surface ===
15825
15826    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15827    VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
15828                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
15829                                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
15830                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15831#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15832    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15833    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15834      createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,
15835                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15836                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15837#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15838    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15839    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15840      createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,
15841                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15842                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15843#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15844#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15845#endif     /*VK_USE_PLATFORM_VI_NN*/
15846
15847    //=== VK_KHR_device_group_creation ===
15848
15849    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15850    VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t *                                            pPhysicalDeviceGroupCount,
15851                                                                  VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
15852                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15853#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15854    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
15855              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15856    VULKAN_HPP_NODISCARD
15857      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
15858      enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15859    template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
15860              typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15861              typename B1                                     = PhysicalDeviceGroupPropertiesAllocator,
15862              typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value, int>::type = 0>
15863    VULKAN_HPP_NODISCARD
15864      typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
15865      enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
15866                                        Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15867#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15868
15869#if defined( VK_USE_PLATFORM_IOS_MVK )
15870    //=== VK_MVK_ios_surface ===
15871
15872    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15873    VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
15874                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
15875                                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
15876                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15877#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15878    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15879    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15880      createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,
15881                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15882                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15883#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15884    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15885    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15886      createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,
15887                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15888                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15889#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15890#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15891#endif     /*VK_USE_PLATFORM_IOS_MVK*/
15892
15893#if defined( VK_USE_PLATFORM_MACOS_MVK )
15894    //=== VK_MVK_macos_surface ===
15895
15896    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15897    VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
15898                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
15899                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
15900                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15901#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15902    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15903    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15904      createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,
15905                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15906                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15907#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15908    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15909    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15910      createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,
15911                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15912                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15913#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15914#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15915#endif     /*VK_USE_PLATFORM_MACOS_MVK*/
15916
15917    //=== VK_EXT_debug_utils ===
15918
15919    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15920    VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
15921                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
15922                                                              VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
15923                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15924#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15925    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15926    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type
15927      createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &      createInfo,
15928                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15929                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15930#  ifndef VULKAN_HPP_NO_SMART_HANDLE
15931    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15932    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
15933      createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &      createInfo,
15934                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15935                                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15936#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15937#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15938
15939    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15940    void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
15941                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15942                                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15943#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15944    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15945    void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15946                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15947                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15948#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15949
15950    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15951    void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
15952                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15953                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15954#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15955    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15956    void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT                        messenger,
15957                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15958                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15959#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15960
15961    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15962    void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
15963                                     VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
15964                                     const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
15965                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15966#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15967    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15968    void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
15969                                     VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
15970                                     const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData,
15971                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15972#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15973
15974#if defined( VK_USE_PLATFORM_FUCHSIA )
15975    //=== VK_FUCHSIA_imagepipe_surface ===
15976
15977    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15978    VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
15979                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
15980                                                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
15981                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15982#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15983    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15984    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
15985      createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,
15986                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15987                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15988#    ifndef VULKAN_HPP_NO_SMART_HANDLE
15989    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15990    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
15991      createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,
15992                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15993                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15994#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15995#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15996#endif     /*VK_USE_PLATFORM_FUCHSIA*/
15997
15998#if defined( VK_USE_PLATFORM_METAL_EXT )
15999    //=== VK_EXT_metal_surface ===
16000
16001    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16002    VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
16003                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
16004                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
16005                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16006#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16007    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16008    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16009      createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,
16010                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16011                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16012#    ifndef VULKAN_HPP_NO_SMART_HANDLE
16013    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16014    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16015      createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,
16016                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16017                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16018#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16019#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16020#endif     /*VK_USE_PLATFORM_METAL_EXT*/
16021
16022    //=== VK_EXT_headless_surface ===
16023
16024    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16025    VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
16026                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
16027                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
16028                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16029#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16030    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16031    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16032      createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &          createInfo,
16033                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16034                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16035#  ifndef VULKAN_HPP_NO_SMART_HANDLE
16036    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16037    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16038      createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &          createInfo,
16039                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16040                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16041#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
16042#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16043
16044#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
16045    //=== VK_EXT_directfb_surface ===
16046
16047    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16048    VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
16049                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
16050                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
16051                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16052#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16053    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16054    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16055      createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,
16056                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16057                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16058#    ifndef VULKAN_HPP_NO_SMART_HANDLE
16059    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16060    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16061      createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,
16062                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16063                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16064#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16065#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16066#endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
16067
16068#if defined( VK_USE_PLATFORM_SCREEN_QNX )
16069    //=== VK_QNX_screen_surface ===
16070
16071    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16072    VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
16073                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
16074                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,
16075                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16076#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16077    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16078    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16079      createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,
16080                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16081                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16082#    ifndef VULKAN_HPP_NO_SMART_HANDLE
16083    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16084    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16085      createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,
16086                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16087                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16088#    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16089#  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16090#endif     /*VK_USE_PLATFORM_SCREEN_QNX*/
16091
16092    operator VkInstance() const VULKAN_HPP_NOEXCEPT
16093    {
16094      return m_instance;
16095    }
16096
16097    explicit operator bool() const VULKAN_HPP_NOEXCEPT
16098    {
16099      return m_instance != VK_NULL_HANDLE;
16100    }
16101
16102    bool operator!() const VULKAN_HPP_NOEXCEPT
16103    {
16104      return m_instance == VK_NULL_HANDLE;
16105    }
16106
16107  private:
16108    VkInstance m_instance = {};
16109  };
16110
16111  template <>
16112  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
16113  {
16114    using Type = VULKAN_HPP_NAMESPACE::Instance;
16115  };
16116
16117  template <>
16118  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
16119  {
16120    using Type = VULKAN_HPP_NAMESPACE::Instance;
16121  };
16122
16123  template <>
16124  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
16125  {
16126    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
16127  };
16128
16129  //=== VK_VERSION_1_0 ===
16130
16131  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16132  VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *  pCreateInfo,
16133                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16134                                              VULKAN_HPP_NAMESPACE::Instance *                  pInstance,
16135                                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
16136#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16137  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16138  VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type
16139    createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,
16140                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16141                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16142#  ifndef VULKAN_HPP_NO_SMART_HANDLE
16143  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16144  VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type
16145    createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,
16146                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16147                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16148#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
16149#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16150
16151  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16152  VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char *                                pLayerName,
16153                                                                    uint32_t *                                  pPropertyCount,
16154                                                                    VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
16155                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
16156#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16157  template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
16158            typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16159  VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
16160    enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16161                                          Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16162  template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
16163            typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16164            typename B1                           = ExtensionPropertiesAllocator,
16165            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
16166  VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
16167    enumerateInstanceExtensionProperties( Optional<const std::string>    layerName,
16168                                          ExtensionPropertiesAllocator & extensionPropertiesAllocator,
16169                                          Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16170#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16171
16172  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16173  VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t *                              pPropertyCount,
16174                                                                VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
16175                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
16176#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16177  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16178  VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
16179    enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16180  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
16181            typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16182            typename B1                       = LayerPropertiesAllocator,
16183            typename std::enable_if<std::is_same<typename B1::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
16184  VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
16185    enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16186#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16187
16188  //=== VK_VERSION_1_1 ===
16189
16190  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16191  VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t *         pApiVersion,
16192                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
16193#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16194  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16195  VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16196#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16197
16198}  // namespace VULKAN_HPP_NAMESPACE
16199
16200// operators to compare vk::-handles with nullptr
16201template <typename T>
16202typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( const T & v, std::nullptr_t )
16203{
16204  return !v;
16205}
16206
16207template <typename T>
16208typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( std::nullptr_t, const T & v )
16209{
16210  return !v;
16211}
16212
16213template <typename T>
16214typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( const T & v, std::nullptr_t )
16215{
16216  return v;
16217}
16218
16219template <typename T>
16220typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( std::nullptr_t, const T & v )
16221{
16222  return v;
16223}
16224#endif
16225