• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
11 namespace 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 
SurfaceKHR(std::nullptr_t)2372     VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2373 
SurfaceKHR(VkSurfaceKHR surfaceKHR)2374     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}
2375 
2376 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSurfaceKHR surfaceKHR)2377     SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
2378     {
2379       m_surfaceKHR = surfaceKHR;
2380       return *this;
2381     }
2382 #endif
2383 
operator =(std::nullptr_t)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
operator ==(SurfaceKHR const & rhs) const2393     bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2394     {
2395       return m_surfaceKHR == rhs.m_surfaceKHR;
2396     }
2397 
operator !=(SurfaceKHR const & rhs) const2398     bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2399     {
2400       return m_surfaceKHR != rhs.m_surfaceKHR;
2401     }
2402 
operator <(SurfaceKHR const & rhs) const2403     bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2404     {
2405       return m_surfaceKHR < rhs.m_surfaceKHR;
2406     }
2407 #endif
2408 
operator VkSurfaceKHR() const2409     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
2410     {
2411       return m_surfaceKHR;
2412     }
2413 
operator bool() const2414     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2415     {
2416       return m_surfaceKHR != VK_NULL_HANDLE;
2417     }
2418 
operator !() const2419     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 
DebugReportCallbackEXT(std::nullptr_t)2459     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2460 
DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)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 )
operator =(VkDebugReportCallbackEXT debugReportCallbackEXT)2467     DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
2468     {
2469       m_debugReportCallbackEXT = debugReportCallbackEXT;
2470       return *this;
2471     }
2472 #endif
2473 
operator =(std::nullptr_t)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
operator ==(DebugReportCallbackEXT const & rhs) const2483     bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2484     {
2485       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
2486     }
2487 
operator !=(DebugReportCallbackEXT const & rhs) const2488     bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2489     {
2490       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
2491     }
2492 
operator <(DebugReportCallbackEXT const & rhs) const2493     bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2494     {
2495       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
2496     }
2497 #endif
2498 
operator VkDebugReportCallbackEXT() const2499     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
2500     {
2501       return m_debugReportCallbackEXT;
2502     }
2503 
operator bool() const2504     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2505     {
2506       return m_debugReportCallbackEXT != VK_NULL_HANDLE;
2507     }
2508 
operator !() const2509     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 
DebugUtilsMessengerEXT(std::nullptr_t)2549     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2550 
DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)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 )
operator =(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)2557     DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
2558     {
2559       m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
2560       return *this;
2561     }
2562 #endif
2563 
operator =(std::nullptr_t)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
operator ==(DebugUtilsMessengerEXT const & rhs) const2573     bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2574     {
2575       return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
2576     }
2577 
operator !=(DebugUtilsMessengerEXT const & rhs) const2578     bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2579     {
2580       return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
2581     }
2582 
operator <(DebugUtilsMessengerEXT const & rhs) const2583     bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2584     {
2585       return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
2586     }
2587 #endif
2588 
operator VkDebugUtilsMessengerEXT() const2589     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
2590     {
2591       return m_debugUtilsMessengerEXT;
2592     }
2593 
operator bool() const2594     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2595     {
2596       return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
2597     }
2598 
operator !() const2599     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 
DisplayKHR(std::nullptr_t)2633     VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2634 
DisplayKHR(VkDisplayKHR displayKHR)2635     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
2636 
2637 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDisplayKHR displayKHR)2638     DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
2639     {
2640       m_displayKHR = displayKHR;
2641       return *this;
2642     }
2643 #endif
2644 
operator =(std::nullptr_t)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
operator ==(DisplayKHR const & rhs) const2654     bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2655     {
2656       return m_displayKHR == rhs.m_displayKHR;
2657     }
2658 
operator !=(DisplayKHR const & rhs) const2659     bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2660     {
2661       return m_displayKHR != rhs.m_displayKHR;
2662     }
2663 
operator <(DisplayKHR const & rhs) const2664     bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2665     {
2666       return m_displayKHR < rhs.m_displayKHR;
2667     }
2668 #endif
2669 
operator VkDisplayKHR() const2670     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
2671     {
2672       return m_displayKHR;
2673     }
2674 
operator bool() const2675     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2676     {
2677       return m_displayKHR != VK_NULL_HANDLE;
2678     }
2679 
operator !() const2680     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 
SwapchainKHR(std::nullptr_t)2720     VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2721 
SwapchainKHR(VkSwapchainKHR swapchainKHR)2722     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}
2723 
2724 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSwapchainKHR swapchainKHR)2725     SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
2726     {
2727       m_swapchainKHR = swapchainKHR;
2728       return *this;
2729     }
2730 #endif
2731 
operator =(std::nullptr_t)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
operator ==(SwapchainKHR const & rhs) const2741     bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2742     {
2743       return m_swapchainKHR == rhs.m_swapchainKHR;
2744     }
2745 
operator !=(SwapchainKHR const & rhs) const2746     bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2747     {
2748       return m_swapchainKHR != rhs.m_swapchainKHR;
2749     }
2750 
operator <(SwapchainKHR const & rhs) const2751     bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2752     {
2753       return m_swapchainKHR < rhs.m_swapchainKHR;
2754     }
2755 #endif
2756 
operator VkSwapchainKHR() const2757     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
2758     {
2759       return m_swapchainKHR;
2760     }
2761 
operator bool() const2762     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2763     {
2764       return m_swapchainKHR != VK_NULL_HANDLE;
2765     }
2766 
operator !() const2767     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 
Semaphore(std::nullptr_t)2807     VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2808 
Semaphore(VkSemaphore semaphore)2809     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
2810 
2811 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSemaphore semaphore)2812     Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
2813     {
2814       m_semaphore = semaphore;
2815       return *this;
2816     }
2817 #endif
2818 
operator =(std::nullptr_t)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
operator ==(Semaphore const & rhs) const2828     bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2829     {
2830       return m_semaphore == rhs.m_semaphore;
2831     }
2832 
operator !=(Semaphore const & rhs) const2833     bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2834     {
2835       return m_semaphore != rhs.m_semaphore;
2836     }
2837 
operator <(Semaphore const & rhs) const2838     bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2839     {
2840       return m_semaphore < rhs.m_semaphore;
2841     }
2842 #endif
2843 
operator VkSemaphore() const2844     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
2845     {
2846       return m_semaphore;
2847     }
2848 
operator bool() const2849     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2850     {
2851       return m_semaphore != VK_NULL_HANDLE;
2852     }
2853 
operator !() const2854     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 
Fence(std::nullptr_t)2894     VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2895 
Fence(VkFence fence)2896     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
2897 
2898 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkFence fence)2899     Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
2900     {
2901       m_fence = fence;
2902       return *this;
2903     }
2904 #endif
2905 
operator =(std::nullptr_t)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
operator ==(Fence const & rhs) const2915     bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2916     {
2917       return m_fence == rhs.m_fence;
2918     }
2919 
operator !=(Fence const & rhs) const2920     bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2921     {
2922       return m_fence != rhs.m_fence;
2923     }
2924 
operator <(Fence const & rhs) const2925     bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2926     {
2927       return m_fence < rhs.m_fence;
2928     }
2929 #endif
2930 
operator VkFence() const2931     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
2932     {
2933       return m_fence;
2934     }
2935 
operator bool() const2936     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2937     {
2938       return m_fence != VK_NULL_HANDLE;
2939     }
2940 
operator !() const2941     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 
PerformanceConfigurationINTEL(std::nullptr_t)2981     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2982 
PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)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 )
operator =(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)2989     PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2990     {
2991       m_performanceConfigurationINTEL = performanceConfigurationINTEL;
2992       return *this;
2993     }
2994 #endif
2995 
operator =(std::nullptr_t)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
operator ==(PerformanceConfigurationINTEL const & rhs) const3005     bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3006     {
3007       return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
3008     }
3009 
operator !=(PerformanceConfigurationINTEL const & rhs) const3010     bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3011     {
3012       return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
3013     }
3014 
operator <(PerformanceConfigurationINTEL const & rhs) const3015     bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3016     {
3017       return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
3018     }
3019 #endif
3020 
operator VkPerformanceConfigurationINTEL() const3021     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
3022     {
3023       return m_performanceConfigurationINTEL;
3024     }
3025 
operator bool() const3026     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3027     {
3028       return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
3029     }
3030 
operator !() const3031     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 
QueryPool(std::nullptr_t)3065     VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3066 
QueryPool(VkQueryPool queryPool)3067     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
3068 
3069 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkQueryPool queryPool)3070     QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
3071     {
3072       m_queryPool = queryPool;
3073       return *this;
3074     }
3075 #endif
3076 
operator =(std::nullptr_t)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
operator ==(QueryPool const & rhs) const3086     bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3087     {
3088       return m_queryPool == rhs.m_queryPool;
3089     }
3090 
operator !=(QueryPool const & rhs) const3091     bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3092     {
3093       return m_queryPool != rhs.m_queryPool;
3094     }
3095 
operator <(QueryPool const & rhs) const3096     bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3097     {
3098       return m_queryPool < rhs.m_queryPool;
3099     }
3100 #endif
3101 
operator VkQueryPool() const3102     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
3103     {
3104       return m_queryPool;
3105     }
3106 
operator bool() const3107     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3108     {
3109       return m_queryPool != VK_NULL_HANDLE;
3110     }
3111 
operator !() const3112     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 
Buffer(std::nullptr_t)3152     VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3153 
Buffer(VkBuffer buffer)3154     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
3155 
3156 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBuffer buffer)3157     Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
3158     {
3159       m_buffer = buffer;
3160       return *this;
3161     }
3162 #endif
3163 
operator =(std::nullptr_t)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
operator ==(Buffer const & rhs) const3173     bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3174     {
3175       return m_buffer == rhs.m_buffer;
3176     }
3177 
operator !=(Buffer const & rhs) const3178     bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3179     {
3180       return m_buffer != rhs.m_buffer;
3181     }
3182 
operator <(Buffer const & rhs) const3183     bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3184     {
3185       return m_buffer < rhs.m_buffer;
3186     }
3187 #endif
3188 
operator VkBuffer() const3189     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
3190     {
3191       return m_buffer;
3192     }
3193 
operator bool() const3194     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3195     {
3196       return m_buffer != VK_NULL_HANDLE;
3197     }
3198 
operator !() const3199     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 
PipelineLayout(std::nullptr_t)3239     VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3240 
PipelineLayout(VkPipelineLayout pipelineLayout)3241     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}
3242 
3243 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipelineLayout pipelineLayout)3244     PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
3245     {
3246       m_pipelineLayout = pipelineLayout;
3247       return *this;
3248     }
3249 #endif
3250 
operator =(std::nullptr_t)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
operator ==(PipelineLayout const & rhs) const3260     bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3261     {
3262       return m_pipelineLayout == rhs.m_pipelineLayout;
3263     }
3264 
operator !=(PipelineLayout const & rhs) const3265     bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3266     {
3267       return m_pipelineLayout != rhs.m_pipelineLayout;
3268     }
3269 
operator <(PipelineLayout const & rhs) const3270     bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3271     {
3272       return m_pipelineLayout < rhs.m_pipelineLayout;
3273     }
3274 #endif
3275 
operator VkPipelineLayout() const3276     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
3277     {
3278       return m_pipelineLayout;
3279     }
3280 
operator bool() const3281     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3282     {
3283       return m_pipelineLayout != VK_NULL_HANDLE;
3284     }
3285 
operator !() const3286     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 
DescriptorSet(std::nullptr_t)3326     VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3327 
DescriptorSet(VkDescriptorSet descriptorSet)3328     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}
3329 
3330 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorSet descriptorSet)3331     DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
3332     {
3333       m_descriptorSet = descriptorSet;
3334       return *this;
3335     }
3336 #endif
3337 
operator =(std::nullptr_t)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
operator ==(DescriptorSet const & rhs) const3347     bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3348     {
3349       return m_descriptorSet == rhs.m_descriptorSet;
3350     }
3351 
operator !=(DescriptorSet const & rhs) const3352     bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3353     {
3354       return m_descriptorSet != rhs.m_descriptorSet;
3355     }
3356 
operator <(DescriptorSet const & rhs) const3357     bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3358     {
3359       return m_descriptorSet < rhs.m_descriptorSet;
3360     }
3361 #endif
3362 
operator VkDescriptorSet() const3363     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
3364     {
3365       return m_descriptorSet;
3366     }
3367 
operator bool() const3368     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3369     {
3370       return m_descriptorSet != VK_NULL_HANDLE;
3371     }
3372 
operator !() const3373     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 
ImageView(std::nullptr_t)3413     VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3414 
ImageView(VkImageView imageView)3415     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
3416 
3417 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkImageView imageView)3418     ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
3419     {
3420       m_imageView = imageView;
3421       return *this;
3422     }
3423 #endif
3424 
operator =(std::nullptr_t)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
operator ==(ImageView const & rhs) const3434     bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3435     {
3436       return m_imageView == rhs.m_imageView;
3437     }
3438 
operator !=(ImageView const & rhs) const3439     bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3440     {
3441       return m_imageView != rhs.m_imageView;
3442     }
3443 
operator <(ImageView const & rhs) const3444     bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3445     {
3446       return m_imageView < rhs.m_imageView;
3447     }
3448 #endif
3449 
operator VkImageView() const3450     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
3451     {
3452       return m_imageView;
3453     }
3454 
operator bool() const3455     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3456     {
3457       return m_imageView != VK_NULL_HANDLE;
3458     }
3459 
operator !() const3460     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 
Pipeline(std::nullptr_t)3500     VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3501 
Pipeline(VkPipeline pipeline)3502     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
3503 
3504 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipeline pipeline)3505     Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
3506     {
3507       m_pipeline = pipeline;
3508       return *this;
3509     }
3510 #endif
3511 
operator =(std::nullptr_t)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
operator ==(Pipeline const & rhs) const3521     bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3522     {
3523       return m_pipeline == rhs.m_pipeline;
3524     }
3525 
operator !=(Pipeline const & rhs) const3526     bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3527     {
3528       return m_pipeline != rhs.m_pipeline;
3529     }
3530 
operator <(Pipeline const & rhs) const3531     bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3532     {
3533       return m_pipeline < rhs.m_pipeline;
3534     }
3535 #endif
3536 
operator VkPipeline() const3537     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
3538     {
3539       return m_pipeline;
3540     }
3541 
operator bool() const3542     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3543     {
3544       return m_pipeline != VK_NULL_HANDLE;
3545     }
3546 
operator !() const3547     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 
ShaderEXT(std::nullptr_t)3587     VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3588 
ShaderEXT(VkShaderEXT shaderEXT)3589     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {}
3590 
3591 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkShaderEXT shaderEXT)3592     ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT
3593     {
3594       m_shaderEXT = shaderEXT;
3595       return *this;
3596     }
3597 #endif
3598 
operator =(std::nullptr_t)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
operator ==(ShaderEXT const & rhs) const3608     bool operator==( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3609     {
3610       return m_shaderEXT == rhs.m_shaderEXT;
3611     }
3612 
operator !=(ShaderEXT const & rhs) const3613     bool operator!=( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3614     {
3615       return m_shaderEXT != rhs.m_shaderEXT;
3616     }
3617 
operator <(ShaderEXT const & rhs) const3618     bool operator<( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3619     {
3620       return m_shaderEXT < rhs.m_shaderEXT;
3621     }
3622 #endif
3623 
operator VkShaderEXT() const3624     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT
3625     {
3626       return m_shaderEXT;
3627     }
3628 
operator bool() const3629     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3630     {
3631       return m_shaderEXT != VK_NULL_HANDLE;
3632     }
3633 
operator !() const3634     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 
Image(std::nullptr_t)3668     VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3669 
Image(VkImage image)3670     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
3671 
3672 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkImage image)3673     Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
3674     {
3675       m_image = image;
3676       return *this;
3677     }
3678 #endif
3679 
operator =(std::nullptr_t)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
operator ==(Image const & rhs) const3689     bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3690     {
3691       return m_image == rhs.m_image;
3692     }
3693 
operator !=(Image const & rhs) const3694     bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3695     {
3696       return m_image != rhs.m_image;
3697     }
3698 
operator <(Image const & rhs) const3699     bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3700     {
3701       return m_image < rhs.m_image;
3702     }
3703 #endif
3704 
operator VkImage() const3705     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
3706     {
3707       return m_image;
3708     }
3709 
operator bool() const3710     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3711     {
3712       return m_image != VK_NULL_HANDLE;
3713     }
3714 
operator !() const3715     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 
AccelerationStructureNV(std::nullptr_t)3755     VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3756 
AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV)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 )
operator =(VkAccelerationStructureNV accelerationStructureNV)3763     AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
3764     {
3765       m_accelerationStructureNV = accelerationStructureNV;
3766       return *this;
3767     }
3768 #endif
3769 
operator =(std::nullptr_t)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
operator ==(AccelerationStructureNV const & rhs) const3779     bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3780     {
3781       return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
3782     }
3783 
operator !=(AccelerationStructureNV const & rhs) const3784     bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3785     {
3786       return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
3787     }
3788 
operator <(AccelerationStructureNV const & rhs) const3789     bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3790     {
3791       return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
3792     }
3793 #endif
3794 
operator VkAccelerationStructureNV() const3795     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
3796     {
3797       return m_accelerationStructureNV;
3798     }
3799 
operator bool() const3800     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3801     {
3802       return m_accelerationStructureNV != VK_NULL_HANDLE;
3803     }
3804 
operator !() const3805     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 
OpticalFlowSessionNV(std::nullptr_t)3845     VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3846 
OpticalFlowSessionNV(VkOpticalFlowSessionNV opticalFlowSessionNV)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 )
operator =(VkOpticalFlowSessionNV opticalFlowSessionNV)3853     OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
3854     {
3855       m_opticalFlowSessionNV = opticalFlowSessionNV;
3856       return *this;
3857     }
3858 #endif
3859 
operator =(std::nullptr_t)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
operator ==(OpticalFlowSessionNV const & rhs) const3869     bool operator==( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3870     {
3871       return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;
3872     }
3873 
operator !=(OpticalFlowSessionNV const & rhs) const3874     bool operator!=( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3875     {
3876       return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;
3877     }
3878 
operator <(OpticalFlowSessionNV const & rhs) const3879     bool operator<( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3880     {
3881       return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;
3882     }
3883 #endif
3884 
operator VkOpticalFlowSessionNV() const3885     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
3886     {
3887       return m_opticalFlowSessionNV;
3888     }
3889 
operator bool() const3890     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3891     {
3892       return m_opticalFlowSessionNV != VK_NULL_HANDLE;
3893     }
3894 
operator !() const3895     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 
DescriptorUpdateTemplate(std::nullptr_t)3929     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3930 
DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate)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 )
operator =(VkDescriptorUpdateTemplate descriptorUpdateTemplate)3937     DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
3938     {
3939       m_descriptorUpdateTemplate = descriptorUpdateTemplate;
3940       return *this;
3941     }
3942 #endif
3943 
operator =(std::nullptr_t)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
operator ==(DescriptorUpdateTemplate const & rhs) const3953     bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3954     {
3955       return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
3956     }
3957 
operator !=(DescriptorUpdateTemplate const & rhs) const3958     bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3959     {
3960       return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
3961     }
3962 
operator <(DescriptorUpdateTemplate const & rhs) const3963     bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3964     {
3965       return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
3966     }
3967 #endif
3968 
operator VkDescriptorUpdateTemplate() const3969     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
3970     {
3971       return m_descriptorUpdateTemplate;
3972     }
3973 
operator bool() const3974     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3975     {
3976       return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
3977     }
3978 
operator !() const3979     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 
Event(std::nullptr_t)4021     VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4022 
Event(VkEvent event)4023     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
4024 
4025 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkEvent event)4026     Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
4027     {
4028       m_event = event;
4029       return *this;
4030     }
4031 #endif
4032 
operator =(std::nullptr_t)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
operator ==(Event const & rhs) const4042     bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4043     {
4044       return m_event == rhs.m_event;
4045     }
4046 
operator !=(Event const & rhs) const4047     bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4048     {
4049       return m_event != rhs.m_event;
4050     }
4051 
operator <(Event const & rhs) const4052     bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4053     {
4054       return m_event < rhs.m_event;
4055     }
4056 #endif
4057 
operator VkEvent() const4058     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
4059     {
4060       return m_event;
4061     }
4062 
operator bool() const4063     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4064     {
4065       return m_event != VK_NULL_HANDLE;
4066     }
4067 
operator !() const4068     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 
AccelerationStructureKHR(std::nullptr_t)4108     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4109 
AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR)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 )
operator =(VkAccelerationStructureKHR accelerationStructureKHR)4116     AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4117     {
4118       m_accelerationStructureKHR = accelerationStructureKHR;
4119       return *this;
4120     }
4121 #endif
4122 
operator =(std::nullptr_t)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
operator ==(AccelerationStructureKHR const & rhs) const4132     bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4133     {
4134       return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
4135     }
4136 
operator !=(AccelerationStructureKHR const & rhs) const4137     bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4138     {
4139       return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
4140     }
4141 
operator <(AccelerationStructureKHR const & rhs) const4142     bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4143     {
4144       return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
4145     }
4146 #endif
4147 
operator VkAccelerationStructureKHR() const4148     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
4149     {
4150       return m_accelerationStructureKHR;
4151     }
4152 
operator bool() const4153     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4154     {
4155       return m_accelerationStructureKHR != VK_NULL_HANDLE;
4156     }
4157 
operator !() const4158     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 
MicromapEXT(std::nullptr_t)4198     VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4199 
MicromapEXT(VkMicromapEXT micromapEXT)4200     VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}
4201 
4202 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkMicromapEXT micromapEXT)4203     MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
4204     {
4205       m_micromapEXT = micromapEXT;
4206       return *this;
4207     }
4208 #endif
4209 
operator =(std::nullptr_t)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
operator ==(MicromapEXT const & rhs) const4219     bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4220     {
4221       return m_micromapEXT == rhs.m_micromapEXT;
4222     }
4223 
operator !=(MicromapEXT const & rhs) const4224     bool operator!=( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4225     {
4226       return m_micromapEXT != rhs.m_micromapEXT;
4227     }
4228 
operator <(MicromapEXT const & rhs) const4229     bool operator<( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4230     {
4231       return m_micromapEXT < rhs.m_micromapEXT;
4232     }
4233 #endif
4234 
operator VkMicromapEXT() const4235     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT
4236     {
4237       return m_micromapEXT;
4238     }
4239 
operator bool() const4240     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4241     {
4242       return m_micromapEXT != VK_NULL_HANDLE;
4243     }
4244 
operator !() const4245     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 
CommandBuffer(std::nullptr_t)4279     VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4280 
CommandBuffer(VkCommandBuffer commandBuffer)4281     CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}
4282 
operator =(VkCommandBuffer commandBuffer)4283     CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
4284     {
4285       m_commandBuffer = commandBuffer;
4286       return *this;
4287     }
4288 
operator =(std::nullptr_t)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
operator ==(CommandBuffer const & rhs) const4298     bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4299     {
4300       return m_commandBuffer == rhs.m_commandBuffer;
4301     }
4302 
operator !=(CommandBuffer const & rhs) const4303     bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4304     {
4305       return m_commandBuffer != rhs.m_commandBuffer;
4306     }
4307 
operator <(CommandBuffer const & rhs) const4308     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 
operator VkCommandBuffer() const6590     operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
6591     {
6592       return m_commandBuffer;
6593     }
6594 
operator bool() const6595     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6596     {
6597       return m_commandBuffer != VK_NULL_HANDLE;
6598     }
6599 
operator !() const6600     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 
DeviceMemory(std::nullptr_t)6640     VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6641 
DeviceMemory(VkDeviceMemory deviceMemory)6642     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}
6643 
6644 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDeviceMemory deviceMemory)6645     DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
6646     {
6647       m_deviceMemory = deviceMemory;
6648       return *this;
6649     }
6650 #endif
6651 
operator =(std::nullptr_t)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
operator ==(DeviceMemory const & rhs) const6661     bool                                 operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
6662     {
6663       return m_deviceMemory == rhs.m_deviceMemory;
6664     }
6665 
operator !=(DeviceMemory const & rhs) const6666     bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
6667     {
6668       return m_deviceMemory != rhs.m_deviceMemory;
6669     }
6670 
operator <(DeviceMemory const & rhs) const6671     bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
6672     {
6673       return m_deviceMemory < rhs.m_deviceMemory;
6674     }
6675 #endif
6676 
operator VkDeviceMemory() const6677     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
6678     {
6679       return m_deviceMemory;
6680     }
6681 
operator bool() const6682     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6683     {
6684       return m_deviceMemory != VK_NULL_HANDLE;
6685     }
6686 
operator !() const6687     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 
VideoSessionKHR(std::nullptr_t)6727     VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6728 
VideoSessionKHR(VkVideoSessionKHR videoSessionKHR)6729     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}
6730 
6731 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkVideoSessionKHR videoSessionKHR)6732     VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
6733     {
6734       m_videoSessionKHR = videoSessionKHR;
6735       return *this;
6736     }
6737 #endif
6738 
operator =(std::nullptr_t)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
operator ==(VideoSessionKHR const & rhs) const6748     bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6749     {
6750       return m_videoSessionKHR == rhs.m_videoSessionKHR;
6751     }
6752 
operator !=(VideoSessionKHR const & rhs) const6753     bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6754     {
6755       return m_videoSessionKHR != rhs.m_videoSessionKHR;
6756     }
6757 
operator <(VideoSessionKHR const & rhs) const6758     bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6759     {
6760       return m_videoSessionKHR < rhs.m_videoSessionKHR;
6761     }
6762 #endif
6763 
operator VkVideoSessionKHR() const6764     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
6765     {
6766       return m_videoSessionKHR;
6767     }
6768 
operator bool() const6769     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6770     {
6771       return m_videoSessionKHR != VK_NULL_HANDLE;
6772     }
6773 
operator !() const6774     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 
DeferredOperationKHR(std::nullptr_t)6808     VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6809 
DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR)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 )
operator =(VkDeferredOperationKHR deferredOperationKHR)6816     DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
6817     {
6818       m_deferredOperationKHR = deferredOperationKHR;
6819       return *this;
6820     }
6821 #endif
6822 
operator =(std::nullptr_t)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
operator ==(DeferredOperationKHR const & rhs) const6832     bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6833     {
6834       return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
6835     }
6836 
operator !=(DeferredOperationKHR const & rhs) const6837     bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6838     {
6839       return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
6840     }
6841 
operator <(DeferredOperationKHR const & rhs) const6842     bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6843     {
6844       return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
6845     }
6846 #endif
6847 
operator VkDeferredOperationKHR() const6848     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
6849     {
6850       return m_deferredOperationKHR;
6851     }
6852 
operator bool() const6853     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6854     {
6855       return m_deferredOperationKHR != VK_NULL_HANDLE;
6856     }
6857 
operator !() const6858     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 
BufferCollectionFUCHSIA(std::nullptr_t)6893     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6894 
BufferCollectionFUCHSIA(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)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 )
operator =(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)6901     BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
6902     {
6903       m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
6904       return *this;
6905     }
6906 #  endif
6907 
operator =(std::nullptr_t)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
operator ==(BufferCollectionFUCHSIA const & rhs) const6917     bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6918     {
6919       return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
6920     }
6921 
operator !=(BufferCollectionFUCHSIA const & rhs) const6922     bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6923     {
6924       return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
6925     }
6926 
operator <(BufferCollectionFUCHSIA const & rhs) const6927     bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6928     {
6929       return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
6930     }
6931 #  endif
6932 
operator VkBufferCollectionFUCHSIA() const6933     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
6934     {
6935       return m_bufferCollectionFUCHSIA;
6936     }
6937 
operator bool() const6938     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6939     {
6940       return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
6941     }
6942 
operator !() const6943     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 
BufferView(std::nullptr_t)6984     VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6985 
BufferView(VkBufferView bufferView)6986     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}
6987 
6988 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBufferView bufferView)6989     BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
6990     {
6991       m_bufferView = bufferView;
6992       return *this;
6993     }
6994 #endif
6995 
operator =(std::nullptr_t)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
operator ==(BufferView const & rhs) const7005     bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7006     {
7007       return m_bufferView == rhs.m_bufferView;
7008     }
7009 
operator !=(BufferView const & rhs) const7010     bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7011     {
7012       return m_bufferView != rhs.m_bufferView;
7013     }
7014 
operator <(BufferView const & rhs) const7015     bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7016     {
7017       return m_bufferView < rhs.m_bufferView;
7018     }
7019 #endif
7020 
operator VkBufferView() const7021     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
7022     {
7023       return m_bufferView;
7024     }
7025 
operator bool() const7026     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7027     {
7028       return m_bufferView != VK_NULL_HANDLE;
7029     }
7030 
operator !() const7031     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 
CommandPool(std::nullptr_t)7071     VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7072 
CommandPool(VkCommandPool commandPool)7073     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}
7074 
7075 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCommandPool commandPool)7076     CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
7077     {
7078       m_commandPool = commandPool;
7079       return *this;
7080     }
7081 #endif
7082 
operator =(std::nullptr_t)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
operator ==(CommandPool const & rhs) const7092     bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7093     {
7094       return m_commandPool == rhs.m_commandPool;
7095     }
7096 
operator !=(CommandPool const & rhs) const7097     bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7098     {
7099       return m_commandPool != rhs.m_commandPool;
7100     }
7101 
operator <(CommandPool const & rhs) const7102     bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7103     {
7104       return m_commandPool < rhs.m_commandPool;
7105     }
7106 #endif
7107 
operator VkCommandPool() const7108     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
7109     {
7110       return m_commandPool;
7111     }
7112 
operator bool() const7113     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7114     {
7115       return m_commandPool != VK_NULL_HANDLE;
7116     }
7117 
operator !() const7118     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 
PipelineCache(std::nullptr_t)7158     VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7159 
PipelineCache(VkPipelineCache pipelineCache)7160     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}
7161 
7162 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipelineCache pipelineCache)7163     PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
7164     {
7165       m_pipelineCache = pipelineCache;
7166       return *this;
7167     }
7168 #endif
7169 
operator =(std::nullptr_t)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
operator ==(PipelineCache const & rhs) const7179     bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7180     {
7181       return m_pipelineCache == rhs.m_pipelineCache;
7182     }
7183 
operator !=(PipelineCache const & rhs) const7184     bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7185     {
7186       return m_pipelineCache != rhs.m_pipelineCache;
7187     }
7188 
operator <(PipelineCache const & rhs) const7189     bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7190     {
7191       return m_pipelineCache < rhs.m_pipelineCache;
7192     }
7193 #endif
7194 
operator VkPipelineCache() const7195     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
7196     {
7197       return m_pipelineCache;
7198     }
7199 
operator bool() const7200     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7201     {
7202       return m_pipelineCache != VK_NULL_HANDLE;
7203     }
7204 
operator !() const7205     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 
CuFunctionNVX(std::nullptr_t)7245     VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7246 
CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX)7247     VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}
7248 
7249 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCuFunctionNVX cuFunctionNVX)7250     CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
7251     {
7252       m_cuFunctionNVX = cuFunctionNVX;
7253       return *this;
7254     }
7255 #endif
7256 
operator =(std::nullptr_t)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
operator ==(CuFunctionNVX const & rhs) const7266     bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7267     {
7268       return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
7269     }
7270 
operator !=(CuFunctionNVX const & rhs) const7271     bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7272     {
7273       return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
7274     }
7275 
operator <(CuFunctionNVX const & rhs) const7276     bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7277     {
7278       return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
7279     }
7280 #endif
7281 
operator VkCuFunctionNVX() const7282     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
7283     {
7284       return m_cuFunctionNVX;
7285     }
7286 
operator bool() const7287     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7288     {
7289       return m_cuFunctionNVX != VK_NULL_HANDLE;
7290     }
7291 
operator !() const7292     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 
CuModuleNVX(std::nullptr_t)7332     VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7333 
CuModuleNVX(VkCuModuleNVX cuModuleNVX)7334     VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}
7335 
7336 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCuModuleNVX cuModuleNVX)7337     CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
7338     {
7339       m_cuModuleNVX = cuModuleNVX;
7340       return *this;
7341     }
7342 #endif
7343 
operator =(std::nullptr_t)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
operator ==(CuModuleNVX const & rhs) const7353     bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7354     {
7355       return m_cuModuleNVX == rhs.m_cuModuleNVX;
7356     }
7357 
operator !=(CuModuleNVX const & rhs) const7358     bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7359     {
7360       return m_cuModuleNVX != rhs.m_cuModuleNVX;
7361     }
7362 
operator <(CuModuleNVX const & rhs) const7363     bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7364     {
7365       return m_cuModuleNVX < rhs.m_cuModuleNVX;
7366     }
7367 #endif
7368 
operator VkCuModuleNVX() const7369     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
7370     {
7371       return m_cuModuleNVX;
7372     }
7373 
operator bool() const7374     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7375     {
7376       return m_cuModuleNVX != VK_NULL_HANDLE;
7377     }
7378 
operator !() const7379     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 
CudaFunctionNV(std::nullptr_t)7420     VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7421 
CudaFunctionNV(VkCudaFunctionNV cudaFunctionNV)7422     VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {}
7423 
7424 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCudaFunctionNV cudaFunctionNV)7425     CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT
7426     {
7427       m_cudaFunctionNV = cudaFunctionNV;
7428       return *this;
7429     }
7430 #  endif
7431 
operator =(std::nullptr_t)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
operator ==(CudaFunctionNV const & rhs) const7441     bool operator==( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7442     {
7443       return m_cudaFunctionNV == rhs.m_cudaFunctionNV;
7444     }
7445 
operator !=(CudaFunctionNV const & rhs) const7446     bool operator!=( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7447     {
7448       return m_cudaFunctionNV != rhs.m_cudaFunctionNV;
7449     }
7450 
operator <(CudaFunctionNV const & rhs) const7451     bool operator<( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7452     {
7453       return m_cudaFunctionNV < rhs.m_cudaFunctionNV;
7454     }
7455 #  endif
7456 
operator VkCudaFunctionNV() const7457     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT
7458     {
7459       return m_cudaFunctionNV;
7460     }
7461 
operator bool() const7462     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7463     {
7464       return m_cudaFunctionNV != VK_NULL_HANDLE;
7465     }
7466 
operator !() const7467     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 
CudaModuleNV(std::nullptr_t)7509     VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7510 
CudaModuleNV(VkCudaModuleNV cudaModuleNV)7511     VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {}
7512 
7513 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCudaModuleNV cudaModuleNV)7514     CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT
7515     {
7516       m_cudaModuleNV = cudaModuleNV;
7517       return *this;
7518     }
7519 #  endif
7520 
operator =(std::nullptr_t)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
operator ==(CudaModuleNV const & rhs) const7530     bool operator==( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7531     {
7532       return m_cudaModuleNV == rhs.m_cudaModuleNV;
7533     }
7534 
operator !=(CudaModuleNV const & rhs) const7535     bool operator!=( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7536     {
7537       return m_cudaModuleNV != rhs.m_cudaModuleNV;
7538     }
7539 
operator <(CudaModuleNV const & rhs) const7540     bool operator<( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7541     {
7542       return m_cudaModuleNV < rhs.m_cudaModuleNV;
7543     }
7544 #  endif
7545 
operator VkCudaModuleNV() const7546     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT
7547     {
7548       return m_cudaModuleNV;
7549     }
7550 
operator bool() const7551     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7552     {
7553       return m_cudaModuleNV != VK_NULL_HANDLE;
7554     }
7555 
operator !() const7556     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 
DescriptorPool(std::nullptr_t)7597     VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7598 
DescriptorPool(VkDescriptorPool descriptorPool)7599     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}
7600 
7601 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorPool descriptorPool)7602     DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
7603     {
7604       m_descriptorPool = descriptorPool;
7605       return *this;
7606     }
7607 #endif
7608 
operator =(std::nullptr_t)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
operator ==(DescriptorPool const & rhs) const7618     bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7619     {
7620       return m_descriptorPool == rhs.m_descriptorPool;
7621     }
7622 
operator !=(DescriptorPool const & rhs) const7623     bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7624     {
7625       return m_descriptorPool != rhs.m_descriptorPool;
7626     }
7627 
operator <(DescriptorPool const & rhs) const7628     bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7629     {
7630       return m_descriptorPool < rhs.m_descriptorPool;
7631     }
7632 #endif
7633 
operator VkDescriptorPool() const7634     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
7635     {
7636       return m_descriptorPool;
7637     }
7638 
operator bool() const7639     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7640     {
7641       return m_descriptorPool != VK_NULL_HANDLE;
7642     }
7643 
operator !() const7644     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 
DescriptorSetLayout(std::nullptr_t)7684     VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7685 
DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)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 )
operator =(VkDescriptorSetLayout descriptorSetLayout)7692     DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
7693     {
7694       m_descriptorSetLayout = descriptorSetLayout;
7695       return *this;
7696     }
7697 #endif
7698 
operator =(std::nullptr_t)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
operator ==(DescriptorSetLayout const & rhs) const7708     bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
7709     {
7710       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
7711     }
7712 
operator !=(DescriptorSetLayout const & rhs) const7713     bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
7714     {
7715       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
7716     }
7717 
operator <(DescriptorSetLayout const & rhs) const7718     bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
7719     {
7720       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
7721     }
7722 #endif
7723 
operator VkDescriptorSetLayout() const7724     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
7725     {
7726       return m_descriptorSetLayout;
7727     }
7728 
operator bool() const7729     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7730     {
7731       return m_descriptorSetLayout != VK_NULL_HANDLE;
7732     }
7733 
operator !() const7734     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 
Framebuffer(std::nullptr_t)7774     VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7775 
Framebuffer(VkFramebuffer framebuffer)7776     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {}
7777 
7778 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkFramebuffer framebuffer)7779     Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
7780     {
7781       m_framebuffer = framebuffer;
7782       return *this;
7783     }
7784 #endif
7785 
operator =(std::nullptr_t)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
operator ==(Framebuffer const & rhs) const7795     bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
7796     {
7797       return m_framebuffer == rhs.m_framebuffer;
7798     }
7799 
operator !=(Framebuffer const & rhs) const7800     bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
7801     {
7802       return m_framebuffer != rhs.m_framebuffer;
7803     }
7804 
operator <(Framebuffer const & rhs) const7805     bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
7806     {
7807       return m_framebuffer < rhs.m_framebuffer;
7808     }
7809 #endif
7810 
operator VkFramebuffer() const7811     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
7812     {
7813       return m_framebuffer;
7814     }
7815 
operator bool() const7816     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7817     {
7818       return m_framebuffer != VK_NULL_HANDLE;
7819     }
7820 
operator !() const7821     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 
IndirectCommandsLayoutNV(std::nullptr_t)7861     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7862 
IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)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 )
operator =(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)7869     IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
7870     {
7871       m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
7872       return *this;
7873     }
7874 #endif
7875 
operator =(std::nullptr_t)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
operator ==(IndirectCommandsLayoutNV const & rhs) const7885     bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7886     {
7887       return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
7888     }
7889 
operator !=(IndirectCommandsLayoutNV const & rhs) const7890     bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7891     {
7892       return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
7893     }
7894 
operator <(IndirectCommandsLayoutNV const & rhs) const7895     bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7896     {
7897       return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
7898     }
7899 #endif
7900 
operator VkIndirectCommandsLayoutNV() const7901     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
7902     {
7903       return m_indirectCommandsLayoutNV;
7904     }
7905 
operator bool() const7906     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7907     {
7908       return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
7909     }
7910 
operator !() const7911     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 
PrivateDataSlot(std::nullptr_t)7945     VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7946 
PrivateDataSlot(VkPrivateDataSlot privateDataSlot)7947     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}
7948 
7949 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPrivateDataSlot privateDataSlot)7950     PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
7951     {
7952       m_privateDataSlot = privateDataSlot;
7953       return *this;
7954     }
7955 #endif
7956 
operator =(std::nullptr_t)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
operator ==(PrivateDataSlot const & rhs) const7966     bool operator==( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
7967     {
7968       return m_privateDataSlot == rhs.m_privateDataSlot;
7969     }
7970 
operator !=(PrivateDataSlot const & rhs) const7971     bool operator!=( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
7972     {
7973       return m_privateDataSlot != rhs.m_privateDataSlot;
7974     }
7975 
operator <(PrivateDataSlot const & rhs) const7976     bool operator<( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
7977     {
7978       return m_privateDataSlot < rhs.m_privateDataSlot;
7979     }
7980 #endif
7981 
operator VkPrivateDataSlot() const7982     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
7983     {
7984       return m_privateDataSlot;
7985     }
7986 
operator bool() const7987     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7988     {
7989       return m_privateDataSlot != VK_NULL_HANDLE;
7990     }
7991 
operator !() const7992     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 
RenderPass(std::nullptr_t)8028     VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8029 
RenderPass(VkRenderPass renderPass)8030     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}
8031 
8032 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkRenderPass renderPass)8033     RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
8034     {
8035       m_renderPass = renderPass;
8036       return *this;
8037     }
8038 #endif
8039 
operator =(std::nullptr_t)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
operator ==(RenderPass const & rhs) const8049     bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8050     {
8051       return m_renderPass == rhs.m_renderPass;
8052     }
8053 
operator !=(RenderPass const & rhs) const8054     bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8055     {
8056       return m_renderPass != rhs.m_renderPass;
8057     }
8058 
operator <(RenderPass const & rhs) const8059     bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8060     {
8061       return m_renderPass < rhs.m_renderPass;
8062     }
8063 #endif
8064 
operator VkRenderPass() const8065     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
8066     {
8067       return m_renderPass;
8068     }
8069 
operator bool() const8070     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8071     {
8072       return m_renderPass != VK_NULL_HANDLE;
8073     }
8074 
operator !() const8075     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 
Sampler(std::nullptr_t)8115     VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8116 
Sampler(VkSampler sampler)8117     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
8118 
8119 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSampler sampler)8120     Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
8121     {
8122       m_sampler = sampler;
8123       return *this;
8124     }
8125 #endif
8126 
operator =(std::nullptr_t)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
operator ==(Sampler const & rhs) const8136     bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8137     {
8138       return m_sampler == rhs.m_sampler;
8139     }
8140 
operator !=(Sampler const & rhs) const8141     bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8142     {
8143       return m_sampler != rhs.m_sampler;
8144     }
8145 
operator <(Sampler const & rhs) const8146     bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8147     {
8148       return m_sampler < rhs.m_sampler;
8149     }
8150 #endif
8151 
operator VkSampler() const8152     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
8153     {
8154       return m_sampler;
8155     }
8156 
operator bool() const8157     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8158     {
8159       return m_sampler != VK_NULL_HANDLE;
8160     }
8161 
operator !() const8162     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 
SamplerYcbcrConversion(std::nullptr_t)8202     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8203 
SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)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 )
operator =(VkSamplerYcbcrConversion samplerYcbcrConversion)8210     SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
8211     {
8212       m_samplerYcbcrConversion = samplerYcbcrConversion;
8213       return *this;
8214     }
8215 #endif
8216 
operator =(std::nullptr_t)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
operator ==(SamplerYcbcrConversion const & rhs) const8226     bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
8227     {
8228       return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
8229     }
8230 
operator !=(SamplerYcbcrConversion const & rhs) const8231     bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
8232     {
8233       return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
8234     }
8235 
operator <(SamplerYcbcrConversion const & rhs) const8236     bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
8237     {
8238       return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
8239     }
8240 #endif
8241 
operator VkSamplerYcbcrConversion() const8242     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
8243     {
8244       return m_samplerYcbcrConversion;
8245     }
8246 
operator bool() const8247     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8248     {
8249       return m_samplerYcbcrConversion != VK_NULL_HANDLE;
8250     }
8251 
operator !() const8252     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 
ShaderModule(std::nullptr_t)8294     VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8295 
ShaderModule(VkShaderModule shaderModule)8296     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}
8297 
8298 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkShaderModule shaderModule)8299     ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
8300     {
8301       m_shaderModule = shaderModule;
8302       return *this;
8303     }
8304 #endif
8305 
operator =(std::nullptr_t)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
operator ==(ShaderModule const & rhs) const8315     bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8316     {
8317       return m_shaderModule == rhs.m_shaderModule;
8318     }
8319 
operator !=(ShaderModule const & rhs) const8320     bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8321     {
8322       return m_shaderModule != rhs.m_shaderModule;
8323     }
8324 
operator <(ShaderModule const & rhs) const8325     bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8326     {
8327       return m_shaderModule < rhs.m_shaderModule;
8328     }
8329 #endif
8330 
operator VkShaderModule() const8331     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
8332     {
8333       return m_shaderModule;
8334     }
8335 
operator bool() const8336     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8337     {
8338       return m_shaderModule != VK_NULL_HANDLE;
8339     }
8340 
operator !() const8341     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 
ValidationCacheEXT(std::nullptr_t)8381     VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8382 
ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT)8383     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )
8384     {
8385     }
8386 
8387 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkValidationCacheEXT validationCacheEXT)8388     ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
8389     {
8390       m_validationCacheEXT = validationCacheEXT;
8391       return *this;
8392     }
8393 #endif
8394 
operator =(std::nullptr_t)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
operator ==(ValidationCacheEXT const & rhs) const8404     bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
8405     {
8406       return m_validationCacheEXT == rhs.m_validationCacheEXT;
8407     }
8408 
operator !=(ValidationCacheEXT const & rhs) const8409     bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
8410     {
8411       return m_validationCacheEXT != rhs.m_validationCacheEXT;
8412     }
8413 
operator <(ValidationCacheEXT const & rhs) const8414     bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
8415     {
8416       return m_validationCacheEXT < rhs.m_validationCacheEXT;
8417     }
8418 #endif
8419 
operator VkValidationCacheEXT() const8420     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
8421     {
8422       return m_validationCacheEXT;
8423     }
8424 
operator bool() const8425     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8426     {
8427       return m_validationCacheEXT != VK_NULL_HANDLE;
8428     }
8429 
operator !() const8430     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 
VideoSessionParametersKHR(std::nullptr_t)8470     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8471 
VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR)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 )
operator =(VkVideoSessionParametersKHR videoSessionParametersKHR)8478     VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
8479     {
8480       m_videoSessionParametersKHR = videoSessionParametersKHR;
8481       return *this;
8482     }
8483 #endif
8484 
operator =(std::nullptr_t)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
operator ==(VideoSessionParametersKHR const & rhs) const8494     bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
8495     {
8496       return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
8497     }
8498 
operator !=(VideoSessionParametersKHR const & rhs) const8499     bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
8500     {
8501       return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
8502     }
8503 
operator <(VideoSessionParametersKHR const & rhs) const8504     bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
8505     {
8506       return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
8507     }
8508 #endif
8509 
operator VkVideoSessionParametersKHR() const8510     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
8511     {
8512       return m_videoSessionParametersKHR;
8513     }
8514 
operator bool() const8515     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8516     {
8517       return m_videoSessionParametersKHR != VK_NULL_HANDLE;
8518     }
8519 
operator !() const8520     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 
Queue(std::nullptr_t)8554     VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8555 
Queue(VkQueue queue)8556     Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
8557 
operator =(VkQueue queue)8558     Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
8559     {
8560       m_queue = queue;
8561       return *this;
8562     }
8563 
operator =(std::nullptr_t)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
operator ==(Queue const & rhs) const8573     bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
8574     {
8575       return m_queue == rhs.m_queue;
8576     }
8577 
operator !=(Queue const & rhs) const8578     bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
8579     {
8580       return m_queue != rhs.m_queue;
8581     }
8582 
operator <(Queue const & rhs) const8583     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 
operator VkQueue() const8749     operator VkQueue() const VULKAN_HPP_NOEXCEPT
8750     {
8751       return m_queue;
8752     }
8753 
operator bool() const8754     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8755     {
8756       return m_queue != VK_NULL_HANDLE;
8757     }
8758 
operator !() const8759     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 
Device(std::nullptr_t)8799     VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8800 
Device(VkDevice device)8801     Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
8802 
operator =(VkDevice device)8803     Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
8804     {
8805       m_device = device;
8806       return *this;
8807     }
8808 
operator =(std::nullptr_t)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
operator ==(Device const & rhs) const8818     bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
8819     {
8820       return m_device == rhs.m_device;
8821     }
8822 
operator !=(Device const & rhs) const8823     bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
8824     {
8825       return m_device != rhs.m_device;
8826     }
8827 
operator <(Device const & rhs) const8828     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 
operator VkDevice() const13894     operator VkDevice() const VULKAN_HPP_NOEXCEPT
13895     {
13896       return m_device;
13897     }
13898 
operator bool() const13899     explicit operator bool() const VULKAN_HPP_NOEXCEPT
13900     {
13901       return m_device != VK_NULL_HANDLE;
13902     }
13903 
operator !() const13904     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 
DisplayModeKHR(std::nullptr_t)13944     VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
13945 
DisplayModeKHR(VkDisplayModeKHR displayModeKHR)13946     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}
13947 
13948 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDisplayModeKHR displayModeKHR)13949     DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
13950     {
13951       m_displayModeKHR = displayModeKHR;
13952       return *this;
13953     }
13954 #endif
13955 
operator =(std::nullptr_t)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
operator ==(DisplayModeKHR const & rhs) const13965     bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
13966     {
13967       return m_displayModeKHR == rhs.m_displayModeKHR;
13968     }
13969 
operator !=(DisplayModeKHR const & rhs) const13970     bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
13971     {
13972       return m_displayModeKHR != rhs.m_displayModeKHR;
13973     }
13974 
operator <(DisplayModeKHR const & rhs) const13975     bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
13976     {
13977       return m_displayModeKHR < rhs.m_displayModeKHR;
13978     }
13979 #endif
13980 
operator VkDisplayModeKHR() const13981     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
13982     {
13983       return m_displayModeKHR;
13984     }
13985 
operator bool() const13986     explicit operator bool() const VULKAN_HPP_NOEXCEPT
13987     {
13988       return m_displayModeKHR != VK_NULL_HANDLE;
13989     }
13990 
operator !() const13991     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 
PhysicalDevice(std::nullptr_t)14031     VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
14032 
PhysicalDevice(VkPhysicalDevice physicalDevice)14033     PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}
14034 
operator =(VkPhysicalDevice physicalDevice)14035     PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
14036     {
14037       m_physicalDevice = physicalDevice;
14038       return *this;
14039     }
14040 
operator =(std::nullptr_t)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
operator ==(PhysicalDevice const & rhs) const14050     bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
14051     {
14052       return m_physicalDevice == rhs.m_physicalDevice;
14053     }
14054 
operator !=(PhysicalDevice const & rhs) const14055     bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
14056     {
14057       return m_physicalDevice != rhs.m_physicalDevice;
14058     }
14059 
operator <(PhysicalDevice const & rhs) const14060     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 
operator VkPhysicalDevice() const15399     operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
15400     {
15401       return m_physicalDevice;
15402     }
15403 
operator bool() const15404     explicit operator bool() const VULKAN_HPP_NOEXCEPT
15405     {
15406       return m_physicalDevice != VK_NULL_HANDLE;
15407     }
15408 
operator !() const15409     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 
Instance(std::nullptr_t)15449     VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
15450 
Instance(VkInstance instance)15451     Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
15452 
operator =(VkInstance instance)15453     Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
15454     {
15455       m_instance = instance;
15456       return *this;
15457     }
15458 
operator =(std::nullptr_t)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
operator ==(Instance const & rhs) const15468     bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
15469     {
15470       return m_instance == rhs.m_instance;
15471     }
15472 
operator !=(Instance const & rhs) const15473     bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
15474     {
15475       return m_instance != rhs.m_instance;
15476     }
15477 
operator <(Instance const & rhs) const15478     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 
operator VkInstance() const16092     operator VkInstance() const VULKAN_HPP_NOEXCEPT
16093     {
16094       return m_instance;
16095     }
16096 
operator bool() const16097     explicit operator bool() const VULKAN_HPP_NOEXCEPT
16098     {
16099       return m_instance != VK_NULL_HANDLE;
16100     }
16101 
operator !() const16102     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
16201 template <typename T>
operator ==(const T & v,std::nullptr_t)16202 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( const T & v, std::nullptr_t )
16203 {
16204   return !v;
16205 }
16206 
16207 template <typename T>
operator ==(std::nullptr_t,const T & v)16208 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( std::nullptr_t, const T & v )
16209 {
16210   return !v;
16211 }
16212 
16213 template <typename T>
operator !=(const T & v,std::nullptr_t)16214 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( const T & v, std::nullptr_t )
16215 {
16216   return v;
16217 }
16218 
16219 template <typename T>
operator !=(std::nullptr_t,const T & v)16220 typename 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