xref: /aosp_15_r20/external/swiftshader/include/vulkan/vulkan_handles.hpp (revision 03ce13f70fcc45d86ee91b7ee4cab1936a95046e) 
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   //=== VK_EXT_debug_report ===
526   struct DebugReportCallbackCreateInfoEXT;
527 
528   //=== VK_AMD_rasterization_order ===
529   struct PipelineRasterizationStateRasterizationOrderAMD;
530 
531   //=== VK_EXT_debug_marker ===
532   struct DebugMarkerObjectNameInfoEXT;
533   struct DebugMarkerObjectTagInfoEXT;
534   struct DebugMarkerMarkerInfoEXT;
535 
536   //=== VK_KHR_video_queue ===
537   struct QueueFamilyQueryResultStatusPropertiesKHR;
538   struct QueueFamilyVideoPropertiesKHR;
539   struct VideoProfileInfoKHR;
540   struct VideoProfileListInfoKHR;
541   struct VideoCapabilitiesKHR;
542   struct PhysicalDeviceVideoFormatInfoKHR;
543   struct VideoFormatPropertiesKHR;
544   struct VideoPictureResourceInfoKHR;
545   struct VideoReferenceSlotInfoKHR;
546   struct VideoSessionMemoryRequirementsKHR;
547   struct BindVideoSessionMemoryInfoKHR;
548   struct VideoSessionCreateInfoKHR;
549   struct VideoSessionParametersCreateInfoKHR;
550   struct VideoSessionParametersUpdateInfoKHR;
551   struct VideoBeginCodingInfoKHR;
552   struct VideoEndCodingInfoKHR;
553   struct VideoCodingControlInfoKHR;
554 
555   //=== VK_KHR_video_decode_queue ===
556   struct VideoDecodeCapabilitiesKHR;
557   struct VideoDecodeUsageInfoKHR;
558   struct VideoDecodeInfoKHR;
559 
560   //=== VK_NV_dedicated_allocation ===
561   struct DedicatedAllocationImageCreateInfoNV;
562   struct DedicatedAllocationBufferCreateInfoNV;
563   struct DedicatedAllocationMemoryAllocateInfoNV;
564 
565   //=== VK_EXT_transform_feedback ===
566   struct PhysicalDeviceTransformFeedbackFeaturesEXT;
567   struct PhysicalDeviceTransformFeedbackPropertiesEXT;
568   struct PipelineRasterizationStateStreamCreateInfoEXT;
569 
570   //=== VK_NVX_binary_import ===
571   struct CuModuleCreateInfoNVX;
572   struct CuFunctionCreateInfoNVX;
573   struct CuLaunchInfoNVX;
574 
575   //=== VK_NVX_image_view_handle ===
576   struct ImageViewHandleInfoNVX;
577   struct ImageViewAddressPropertiesNVX;
578 
579   //=== VK_KHR_video_encode_h264 ===
580   struct VideoEncodeH264CapabilitiesKHR;
581   struct VideoEncodeH264QualityLevelPropertiesKHR;
582   struct VideoEncodeH264SessionCreateInfoKHR;
583   struct VideoEncodeH264SessionParametersCreateInfoKHR;
584   struct VideoEncodeH264SessionParametersAddInfoKHR;
585   struct VideoEncodeH264SessionParametersGetInfoKHR;
586   struct VideoEncodeH264SessionParametersFeedbackInfoKHR;
587   struct VideoEncodeH264PictureInfoKHR;
588   struct VideoEncodeH264DpbSlotInfoKHR;
589   struct VideoEncodeH264NaluSliceInfoKHR;
590   struct VideoEncodeH264ProfileInfoKHR;
591   struct VideoEncodeH264RateControlInfoKHR;
592   struct VideoEncodeH264RateControlLayerInfoKHR;
593   struct VideoEncodeH264QpKHR;
594   struct VideoEncodeH264FrameSizeKHR;
595   struct VideoEncodeH264GopRemainingFrameInfoKHR;
596 
597   //=== VK_KHR_video_encode_h265 ===
598   struct VideoEncodeH265CapabilitiesKHR;
599   struct VideoEncodeH265SessionCreateInfoKHR;
600   struct VideoEncodeH265QualityLevelPropertiesKHR;
601   struct VideoEncodeH265SessionParametersCreateInfoKHR;
602   struct VideoEncodeH265SessionParametersAddInfoKHR;
603   struct VideoEncodeH265SessionParametersGetInfoKHR;
604   struct VideoEncodeH265SessionParametersFeedbackInfoKHR;
605   struct VideoEncodeH265PictureInfoKHR;
606   struct VideoEncodeH265DpbSlotInfoKHR;
607   struct VideoEncodeH265NaluSliceSegmentInfoKHR;
608   struct VideoEncodeH265ProfileInfoKHR;
609   struct VideoEncodeH265RateControlInfoKHR;
610   struct VideoEncodeH265RateControlLayerInfoKHR;
611   struct VideoEncodeH265QpKHR;
612   struct VideoEncodeH265FrameSizeKHR;
613   struct VideoEncodeH265GopRemainingFrameInfoKHR;
614 
615   //=== VK_KHR_video_decode_h264 ===
616   struct VideoDecodeH264ProfileInfoKHR;
617   struct VideoDecodeH264CapabilitiesKHR;
618   struct VideoDecodeH264SessionParametersCreateInfoKHR;
619   struct VideoDecodeH264SessionParametersAddInfoKHR;
620   struct VideoDecodeH264PictureInfoKHR;
621   struct VideoDecodeH264DpbSlotInfoKHR;
622 
623   //=== VK_AMD_texture_gather_bias_lod ===
624   struct TextureLODGatherFormatPropertiesAMD;
625 
626   //=== VK_AMD_shader_info ===
627   struct ShaderResourceUsageAMD;
628   struct ShaderStatisticsInfoAMD;
629 
630   //=== VK_KHR_dynamic_rendering ===
631   struct RenderingFragmentShadingRateAttachmentInfoKHR;
632   struct RenderingFragmentDensityMapAttachmentInfoEXT;
633   struct AttachmentSampleCountInfoAMD;
634   using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
635   struct MultiviewPerViewAttributesInfoNVX;
636 
637 #if defined( VK_USE_PLATFORM_GGP )
638   //=== VK_GGP_stream_descriptor_surface ===
639   struct StreamDescriptorSurfaceCreateInfoGGP;
640 #endif /*VK_USE_PLATFORM_GGP*/
641 
642   //=== VK_NV_corner_sampled_image ===
643   struct PhysicalDeviceCornerSampledImageFeaturesNV;
644 
645   //=== VK_NV_external_memory_capabilities ===
646   struct ExternalImageFormatPropertiesNV;
647 
648   //=== VK_NV_external_memory ===
649   struct ExternalMemoryImageCreateInfoNV;
650   struct ExportMemoryAllocateInfoNV;
651 
652 #if defined( VK_USE_PLATFORM_WIN32_KHR )
653   //=== VK_NV_external_memory_win32 ===
654   struct ImportMemoryWin32HandleInfoNV;
655   struct ExportMemoryWin32HandleInfoNV;
656 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
657 
658 #if defined( VK_USE_PLATFORM_WIN32_KHR )
659   //=== VK_NV_win32_keyed_mutex ===
660   struct Win32KeyedMutexAcquireReleaseInfoNV;
661 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
662 
663   //=== VK_EXT_validation_flags ===
664   struct ValidationFlagsEXT;
665 
666 #if defined( VK_USE_PLATFORM_VI_NN )
667   //=== VK_NN_vi_surface ===
668   struct ViSurfaceCreateInfoNN;
669 #endif /*VK_USE_PLATFORM_VI_NN*/
670 
671   //=== VK_EXT_astc_decode_mode ===
672   struct ImageViewASTCDecodeModeEXT;
673   struct PhysicalDeviceASTCDecodeFeaturesEXT;
674 
675   //=== VK_EXT_pipeline_robustness ===
676   struct PhysicalDevicePipelineRobustnessFeaturesEXT;
677   struct PhysicalDevicePipelineRobustnessPropertiesEXT;
678   struct PipelineRobustnessCreateInfoEXT;
679 
680 #if defined( VK_USE_PLATFORM_WIN32_KHR )
681   //=== VK_KHR_external_memory_win32 ===
682   struct ImportMemoryWin32HandleInfoKHR;
683   struct ExportMemoryWin32HandleInfoKHR;
684   struct MemoryWin32HandlePropertiesKHR;
685   struct MemoryGetWin32HandleInfoKHR;
686 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
687 
688   //=== VK_KHR_external_memory_fd ===
689   struct ImportMemoryFdInfoKHR;
690   struct MemoryFdPropertiesKHR;
691   struct MemoryGetFdInfoKHR;
692 
693 #if defined( VK_USE_PLATFORM_WIN32_KHR )
694   //=== VK_KHR_win32_keyed_mutex ===
695   struct Win32KeyedMutexAcquireReleaseInfoKHR;
696 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
697 
698 #if defined( VK_USE_PLATFORM_WIN32_KHR )
699   //=== VK_KHR_external_semaphore_win32 ===
700   struct ImportSemaphoreWin32HandleInfoKHR;
701   struct ExportSemaphoreWin32HandleInfoKHR;
702   struct D3D12FenceSubmitInfoKHR;
703   struct SemaphoreGetWin32HandleInfoKHR;
704 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
705 
706   //=== VK_KHR_external_semaphore_fd ===
707   struct ImportSemaphoreFdInfoKHR;
708   struct SemaphoreGetFdInfoKHR;
709 
710   //=== VK_KHR_push_descriptor ===
711   struct PhysicalDevicePushDescriptorPropertiesKHR;
712 
713   //=== VK_EXT_conditional_rendering ===
714   struct ConditionalRenderingBeginInfoEXT;
715   struct PhysicalDeviceConditionalRenderingFeaturesEXT;
716   struct CommandBufferInheritanceConditionalRenderingInfoEXT;
717 
718   //=== VK_KHR_incremental_present ===
719   struct PresentRegionsKHR;
720   struct PresentRegionKHR;
721   struct RectLayerKHR;
722 
723   //=== VK_NV_clip_space_w_scaling ===
724   struct ViewportWScalingNV;
725   struct PipelineViewportWScalingStateCreateInfoNV;
726 
727   //=== VK_EXT_display_surface_counter ===
728   struct SurfaceCapabilities2EXT;
729 
730   //=== VK_EXT_display_control ===
731   struct DisplayPowerInfoEXT;
732   struct DeviceEventInfoEXT;
733   struct DisplayEventInfoEXT;
734   struct SwapchainCounterCreateInfoEXT;
735 
736   //=== VK_GOOGLE_display_timing ===
737   struct RefreshCycleDurationGOOGLE;
738   struct PastPresentationTimingGOOGLE;
739   struct PresentTimesInfoGOOGLE;
740   struct PresentTimeGOOGLE;
741 
742   //=== VK_NVX_multiview_per_view_attributes ===
743   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
744 
745   //=== VK_NV_viewport_swizzle ===
746   struct ViewportSwizzleNV;
747   struct PipelineViewportSwizzleStateCreateInfoNV;
748 
749   //=== VK_EXT_discard_rectangles ===
750   struct PhysicalDeviceDiscardRectanglePropertiesEXT;
751   struct PipelineDiscardRectangleStateCreateInfoEXT;
752 
753   //=== VK_EXT_conservative_rasterization ===
754   struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
755   struct PipelineRasterizationConservativeStateCreateInfoEXT;
756 
757   //=== VK_EXT_depth_clip_enable ===
758   struct PhysicalDeviceDepthClipEnableFeaturesEXT;
759   struct PipelineRasterizationDepthClipStateCreateInfoEXT;
760 
761   //=== VK_EXT_hdr_metadata ===
762   struct HdrMetadataEXT;
763   struct XYColorEXT;
764 
765   //=== VK_IMG_relaxed_line_rasterization ===
766   struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG;
767 
768   //=== VK_KHR_shared_presentable_image ===
769   struct SharedPresentSurfaceCapabilitiesKHR;
770 
771 #if defined( VK_USE_PLATFORM_WIN32_KHR )
772   //=== VK_KHR_external_fence_win32 ===
773   struct ImportFenceWin32HandleInfoKHR;
774   struct ExportFenceWin32HandleInfoKHR;
775   struct FenceGetWin32HandleInfoKHR;
776 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
777 
778   //=== VK_KHR_external_fence_fd ===
779   struct ImportFenceFdInfoKHR;
780   struct FenceGetFdInfoKHR;
781 
782   //=== VK_KHR_performance_query ===
783   struct PhysicalDevicePerformanceQueryFeaturesKHR;
784   struct PhysicalDevicePerformanceQueryPropertiesKHR;
785   struct PerformanceCounterKHR;
786   struct PerformanceCounterDescriptionKHR;
787   struct QueryPoolPerformanceCreateInfoKHR;
788   union PerformanceCounterResultKHR;
789   struct AcquireProfilingLockInfoKHR;
790   struct PerformanceQuerySubmitInfoKHR;
791 
792   //=== VK_KHR_get_surface_capabilities2 ===
793   struct PhysicalDeviceSurfaceInfo2KHR;
794   struct SurfaceCapabilities2KHR;
795   struct SurfaceFormat2KHR;
796 
797   //=== VK_KHR_get_display_properties2 ===
798   struct DisplayProperties2KHR;
799   struct DisplayPlaneProperties2KHR;
800   struct DisplayModeProperties2KHR;
801   struct DisplayPlaneInfo2KHR;
802   struct DisplayPlaneCapabilities2KHR;
803 
804 #if defined( VK_USE_PLATFORM_IOS_MVK )
805   //=== VK_MVK_ios_surface ===
806   struct IOSSurfaceCreateInfoMVK;
807 #endif /*VK_USE_PLATFORM_IOS_MVK*/
808 
809 #if defined( VK_USE_PLATFORM_MACOS_MVK )
810   //=== VK_MVK_macos_surface ===
811   struct MacOSSurfaceCreateInfoMVK;
812 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
813 
814   //=== VK_EXT_debug_utils ===
815   struct DebugUtilsLabelEXT;
816   struct DebugUtilsMessengerCallbackDataEXT;
817   struct DebugUtilsMessengerCreateInfoEXT;
818   struct DebugUtilsObjectNameInfoEXT;
819   struct DebugUtilsObjectTagInfoEXT;
820 
821 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
822   //=== VK_ANDROID_external_memory_android_hardware_buffer ===
823   struct AndroidHardwareBufferUsageANDROID;
824   struct AndroidHardwareBufferPropertiesANDROID;
825   struct AndroidHardwareBufferFormatPropertiesANDROID;
826   struct ImportAndroidHardwareBufferInfoANDROID;
827   struct MemoryGetAndroidHardwareBufferInfoANDROID;
828   struct ExternalFormatANDROID;
829   struct AndroidHardwareBufferFormatProperties2ANDROID;
830 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
831 
832 #if defined( VK_ENABLE_BETA_EXTENSIONS )
833   //=== VK_AMDX_shader_enqueue ===
834   struct PhysicalDeviceShaderEnqueueFeaturesAMDX;
835   struct PhysicalDeviceShaderEnqueuePropertiesAMDX;
836   struct ExecutionGraphPipelineScratchSizeAMDX;
837   struct ExecutionGraphPipelineCreateInfoAMDX;
838   struct DispatchGraphInfoAMDX;
839   struct DispatchGraphCountInfoAMDX;
840   struct PipelineShaderStageNodeCreateInfoAMDX;
841   union DeviceOrHostAddressConstAMDX;
842 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
843 
844   //=== VK_EXT_sample_locations ===
845   struct SampleLocationEXT;
846   struct SampleLocationsInfoEXT;
847   struct AttachmentSampleLocationsEXT;
848   struct SubpassSampleLocationsEXT;
849   struct RenderPassSampleLocationsBeginInfoEXT;
850   struct PipelineSampleLocationsStateCreateInfoEXT;
851   struct PhysicalDeviceSampleLocationsPropertiesEXT;
852   struct MultisamplePropertiesEXT;
853 
854   //=== VK_EXT_blend_operation_advanced ===
855   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
856   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
857   struct PipelineColorBlendAdvancedStateCreateInfoEXT;
858 
859   //=== VK_NV_fragment_coverage_to_color ===
860   struct PipelineCoverageToColorStateCreateInfoNV;
861 
862   //=== VK_KHR_acceleration_structure ===
863   union DeviceOrHostAddressKHR;
864   union DeviceOrHostAddressConstKHR;
865   struct AccelerationStructureBuildRangeInfoKHR;
866   struct AabbPositionsKHR;
867   using AabbPositionsNV = AabbPositionsKHR;
868   struct AccelerationStructureGeometryTrianglesDataKHR;
869   struct TransformMatrixKHR;
870   using TransformMatrixNV = TransformMatrixKHR;
871   struct AccelerationStructureBuildGeometryInfoKHR;
872   struct AccelerationStructureGeometryAabbsDataKHR;
873   struct AccelerationStructureInstanceKHR;
874   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
875   struct AccelerationStructureGeometryInstancesDataKHR;
876   union AccelerationStructureGeometryDataKHR;
877   struct AccelerationStructureGeometryKHR;
878   struct AccelerationStructureCreateInfoKHR;
879   struct WriteDescriptorSetAccelerationStructureKHR;
880   struct PhysicalDeviceAccelerationStructureFeaturesKHR;
881   struct PhysicalDeviceAccelerationStructurePropertiesKHR;
882   struct AccelerationStructureDeviceAddressInfoKHR;
883   struct AccelerationStructureVersionInfoKHR;
884   struct CopyAccelerationStructureToMemoryInfoKHR;
885   struct CopyMemoryToAccelerationStructureInfoKHR;
886   struct CopyAccelerationStructureInfoKHR;
887   struct AccelerationStructureBuildSizesInfoKHR;
888 
889   //=== VK_KHR_ray_tracing_pipeline ===
890   struct RayTracingShaderGroupCreateInfoKHR;
891   struct RayTracingPipelineCreateInfoKHR;
892   struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
893   struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
894   struct StridedDeviceAddressRegionKHR;
895   struct TraceRaysIndirectCommandKHR;
896   struct RayTracingPipelineInterfaceCreateInfoKHR;
897 
898   //=== VK_KHR_ray_query ===
899   struct PhysicalDeviceRayQueryFeaturesKHR;
900 
901   //=== VK_NV_framebuffer_mixed_samples ===
902   struct PipelineCoverageModulationStateCreateInfoNV;
903 
904   //=== VK_NV_shader_sm_builtins ===
905   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
906   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
907 
908   //=== VK_EXT_image_drm_format_modifier ===
909   struct DrmFormatModifierPropertiesListEXT;
910   struct DrmFormatModifierPropertiesEXT;
911   struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
912   struct ImageDrmFormatModifierListCreateInfoEXT;
913   struct ImageDrmFormatModifierExplicitCreateInfoEXT;
914   struct ImageDrmFormatModifierPropertiesEXT;
915   struct DrmFormatModifierPropertiesList2EXT;
916   struct DrmFormatModifierProperties2EXT;
917 
918   //=== VK_EXT_validation_cache ===
919   struct ValidationCacheCreateInfoEXT;
920   struct ShaderModuleValidationCacheCreateInfoEXT;
921 
922 #if defined( VK_ENABLE_BETA_EXTENSIONS )
923   //=== VK_KHR_portability_subset ===
924   struct PhysicalDevicePortabilitySubsetFeaturesKHR;
925   struct PhysicalDevicePortabilitySubsetPropertiesKHR;
926 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
927 
928   //=== VK_NV_shading_rate_image ===
929   struct ShadingRatePaletteNV;
930   struct PipelineViewportShadingRateImageStateCreateInfoNV;
931   struct PhysicalDeviceShadingRateImageFeaturesNV;
932   struct PhysicalDeviceShadingRateImagePropertiesNV;
933   struct CoarseSampleLocationNV;
934   struct CoarseSampleOrderCustomNV;
935   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
936 
937   //=== VK_NV_ray_tracing ===
938   struct RayTracingShaderGroupCreateInfoNV;
939   struct RayTracingPipelineCreateInfoNV;
940   struct GeometryTrianglesNV;
941   struct GeometryAABBNV;
942   struct GeometryDataNV;
943   struct GeometryNV;
944   struct AccelerationStructureInfoNV;
945   struct AccelerationStructureCreateInfoNV;
946   struct BindAccelerationStructureMemoryInfoNV;
947   struct WriteDescriptorSetAccelerationStructureNV;
948   struct AccelerationStructureMemoryRequirementsInfoNV;
949   struct PhysicalDeviceRayTracingPropertiesNV;
950 
951   //=== VK_NV_representative_fragment_test ===
952   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
953   struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
954 
955   //=== VK_EXT_filter_cubic ===
956   struct PhysicalDeviceImageViewImageFormatInfoEXT;
957   struct FilterCubicImageViewImageFormatPropertiesEXT;
958 
959   //=== VK_EXT_external_memory_host ===
960   struct ImportMemoryHostPointerInfoEXT;
961   struct MemoryHostPointerPropertiesEXT;
962   struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
963 
964   //=== VK_KHR_shader_clock ===
965   struct PhysicalDeviceShaderClockFeaturesKHR;
966 
967   //=== VK_AMD_pipeline_compiler_control ===
968   struct PipelineCompilerControlCreateInfoAMD;
969 
970   //=== VK_AMD_shader_core_properties ===
971   struct PhysicalDeviceShaderCorePropertiesAMD;
972 
973   //=== VK_KHR_video_decode_h265 ===
974   struct VideoDecodeH265ProfileInfoKHR;
975   struct VideoDecodeH265CapabilitiesKHR;
976   struct VideoDecodeH265SessionParametersCreateInfoKHR;
977   struct VideoDecodeH265SessionParametersAddInfoKHR;
978   struct VideoDecodeH265PictureInfoKHR;
979   struct VideoDecodeH265DpbSlotInfoKHR;
980 
981   //=== VK_KHR_global_priority ===
982   struct DeviceQueueGlobalPriorityCreateInfoKHR;
983   using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR;
984   struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
985   using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
986   struct QueueFamilyGlobalPriorityPropertiesKHR;
987   using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR;
988 
989   //=== VK_AMD_memory_overallocation_behavior ===
990   struct DeviceMemoryOverallocationCreateInfoAMD;
991 
992   //=== VK_EXT_vertex_attribute_divisor ===
993   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
994 
995 #if defined( VK_USE_PLATFORM_GGP )
996   //=== VK_GGP_frame_token ===
997   struct PresentFrameTokenGGP;
998 #endif /*VK_USE_PLATFORM_GGP*/
999 
1000   //=== VK_NV_compute_shader_derivatives ===
1001   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
1002 
1003   //=== VK_NV_mesh_shader ===
1004   struct PhysicalDeviceMeshShaderFeaturesNV;
1005   struct PhysicalDeviceMeshShaderPropertiesNV;
1006   struct DrawMeshTasksIndirectCommandNV;
1007 
1008   //=== VK_NV_shader_image_footprint ===
1009   struct PhysicalDeviceShaderImageFootprintFeaturesNV;
1010 
1011   //=== VK_NV_scissor_exclusive ===
1012   struct PipelineViewportExclusiveScissorStateCreateInfoNV;
1013   struct PhysicalDeviceExclusiveScissorFeaturesNV;
1014 
1015   //=== VK_NV_device_diagnostic_checkpoints ===
1016   struct QueueFamilyCheckpointPropertiesNV;
1017   struct CheckpointDataNV;
1018 
1019   //=== VK_INTEL_shader_integer_functions2 ===
1020   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
1021 
1022   //=== VK_INTEL_performance_query ===
1023   union PerformanceValueDataINTEL;
1024   struct PerformanceValueINTEL;
1025   struct InitializePerformanceApiInfoINTEL;
1026   struct QueryPoolPerformanceQueryCreateInfoINTEL;
1027   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
1028   struct PerformanceMarkerInfoINTEL;
1029   struct PerformanceStreamMarkerInfoINTEL;
1030   struct PerformanceOverrideInfoINTEL;
1031   struct PerformanceConfigurationAcquireInfoINTEL;
1032 
1033   //=== VK_EXT_pci_bus_info ===
1034   struct PhysicalDevicePCIBusInfoPropertiesEXT;
1035 
1036   //=== VK_AMD_display_native_hdr ===
1037   struct DisplayNativeHdrSurfaceCapabilitiesAMD;
1038   struct SwapchainDisplayNativeHdrCreateInfoAMD;
1039 
1040 #if defined( VK_USE_PLATFORM_FUCHSIA )
1041   //=== VK_FUCHSIA_imagepipe_surface ===
1042   struct ImagePipeSurfaceCreateInfoFUCHSIA;
1043 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1044 
1045 #if defined( VK_USE_PLATFORM_METAL_EXT )
1046   //=== VK_EXT_metal_surface ===
1047   struct MetalSurfaceCreateInfoEXT;
1048 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1049 
1050   //=== VK_EXT_fragment_density_map ===
1051   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
1052   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
1053   struct RenderPassFragmentDensityMapCreateInfoEXT;
1054 
1055   //=== VK_KHR_fragment_shading_rate ===
1056   struct FragmentShadingRateAttachmentInfoKHR;
1057   struct PipelineFragmentShadingRateStateCreateInfoKHR;
1058   struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
1059   struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
1060   struct PhysicalDeviceFragmentShadingRateKHR;
1061 
1062   //=== VK_AMD_shader_core_properties2 ===
1063   struct PhysicalDeviceShaderCoreProperties2AMD;
1064 
1065   //=== VK_AMD_device_coherent_memory ===
1066   struct PhysicalDeviceCoherentMemoryFeaturesAMD;
1067 
1068   //=== VK_KHR_dynamic_rendering_local_read ===
1069   struct PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
1070   struct RenderingAttachmentLocationInfoKHR;
1071   struct RenderingInputAttachmentIndexInfoKHR;
1072 
1073   //=== VK_EXT_shader_image_atomic_int64 ===
1074   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
1075 
1076   //=== VK_KHR_shader_quad_control ===
1077   struct PhysicalDeviceShaderQuadControlFeaturesKHR;
1078 
1079   //=== VK_EXT_memory_budget ===
1080   struct PhysicalDeviceMemoryBudgetPropertiesEXT;
1081 
1082   //=== VK_EXT_memory_priority ===
1083   struct PhysicalDeviceMemoryPriorityFeaturesEXT;
1084   struct MemoryPriorityAllocateInfoEXT;
1085 
1086   //=== VK_KHR_surface_protected_capabilities ===
1087   struct SurfaceProtectedCapabilitiesKHR;
1088 
1089   //=== VK_NV_dedicated_allocation_image_aliasing ===
1090   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
1091 
1092   //=== VK_EXT_buffer_device_address ===
1093   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1094   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1095   struct BufferDeviceAddressCreateInfoEXT;
1096 
1097   //=== VK_EXT_validation_features ===
1098   struct ValidationFeaturesEXT;
1099 
1100   //=== VK_KHR_present_wait ===
1101   struct PhysicalDevicePresentWaitFeaturesKHR;
1102 
1103   //=== VK_NV_cooperative_matrix ===
1104   struct CooperativeMatrixPropertiesNV;
1105   struct PhysicalDeviceCooperativeMatrixFeaturesNV;
1106   struct PhysicalDeviceCooperativeMatrixPropertiesNV;
1107 
1108   //=== VK_NV_coverage_reduction_mode ===
1109   struct PhysicalDeviceCoverageReductionModeFeaturesNV;
1110   struct PipelineCoverageReductionStateCreateInfoNV;
1111   struct FramebufferMixedSamplesCombinationNV;
1112 
1113   //=== VK_EXT_fragment_shader_interlock ===
1114   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
1115 
1116   //=== VK_EXT_ycbcr_image_arrays ===
1117   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
1118 
1119   //=== VK_EXT_provoking_vertex ===
1120   struct PhysicalDeviceProvokingVertexFeaturesEXT;
1121   struct PhysicalDeviceProvokingVertexPropertiesEXT;
1122   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
1123 
1124 #if defined( VK_USE_PLATFORM_WIN32_KHR )
1125   //=== VK_EXT_full_screen_exclusive ===
1126   struct SurfaceFullScreenExclusiveInfoEXT;
1127   struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1128   struct SurfaceFullScreenExclusiveWin32InfoEXT;
1129 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
1130 
1131   //=== VK_EXT_headless_surface ===
1132   struct HeadlessSurfaceCreateInfoEXT;
1133 
1134   //=== VK_EXT_shader_atomic_float ===
1135   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
1136 
1137   //=== VK_EXT_extended_dynamic_state ===
1138   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
1139 
1140   //=== VK_KHR_pipeline_executable_properties ===
1141   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
1142   struct PipelineInfoKHR;
1143   using PipelineInfoEXT = PipelineInfoKHR;
1144   struct PipelineExecutablePropertiesKHR;
1145   struct PipelineExecutableInfoKHR;
1146   union PipelineExecutableStatisticValueKHR;
1147   struct PipelineExecutableStatisticKHR;
1148   struct PipelineExecutableInternalRepresentationKHR;
1149 
1150   //=== VK_EXT_host_image_copy ===
1151   struct PhysicalDeviceHostImageCopyFeaturesEXT;
1152   struct PhysicalDeviceHostImageCopyPropertiesEXT;
1153   struct MemoryToImageCopyEXT;
1154   struct ImageToMemoryCopyEXT;
1155   struct CopyMemoryToImageInfoEXT;
1156   struct CopyImageToMemoryInfoEXT;
1157   struct CopyImageToImageInfoEXT;
1158   struct HostImageLayoutTransitionInfoEXT;
1159   struct SubresourceHostMemcpySizeEXT;
1160   struct HostImageCopyDevicePerformanceQueryEXT;
1161 
1162   //=== VK_KHR_map_memory2 ===
1163   struct MemoryMapInfoKHR;
1164   struct MemoryUnmapInfoKHR;
1165 
1166   //=== VK_EXT_map_memory_placed ===
1167   struct PhysicalDeviceMapMemoryPlacedFeaturesEXT;
1168   struct PhysicalDeviceMapMemoryPlacedPropertiesEXT;
1169   struct MemoryMapPlacedInfoEXT;
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_KHR_shader_subgroup_rotate ===
1529   struct PhysicalDeviceShaderSubgroupRotateFeaturesKHR;
1530 
1531   //=== VK_ARM_scheduling_controls ===
1532   struct DeviceQueueShaderCoreControlCreateInfoARM;
1533   struct PhysicalDeviceSchedulingControlsFeaturesARM;
1534   struct PhysicalDeviceSchedulingControlsPropertiesARM;
1535 
1536   //=== VK_EXT_image_sliced_view_of_3d ===
1537   struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
1538   struct ImageViewSlicedCreateInfoEXT;
1539 
1540   //=== VK_VALVE_descriptor_set_host_mapping ===
1541   struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
1542   struct DescriptorSetBindingReferenceVALVE;
1543   struct DescriptorSetLayoutHostMappingInfoVALVE;
1544 
1545   //=== VK_EXT_depth_clamp_zero_one ===
1546   struct PhysicalDeviceDepthClampZeroOneFeaturesEXT;
1547 
1548   //=== VK_EXT_non_seamless_cube_map ===
1549   struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
1550 
1551   //=== VK_ARM_render_pass_striped ===
1552   struct PhysicalDeviceRenderPassStripedFeaturesARM;
1553   struct PhysicalDeviceRenderPassStripedPropertiesARM;
1554   struct RenderPassStripeBeginInfoARM;
1555   struct RenderPassStripeInfoARM;
1556   struct RenderPassStripeSubmitInfoARM;
1557 
1558   //=== VK_QCOM_fragment_density_map_offset ===
1559   struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
1560   struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
1561   struct SubpassFragmentDensityMapOffsetEndInfoQCOM;
1562 
1563   //=== VK_NV_copy_memory_indirect ===
1564   struct CopyMemoryIndirectCommandNV;
1565   struct CopyMemoryToImageIndirectCommandNV;
1566   struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;
1567   struct PhysicalDeviceCopyMemoryIndirectPropertiesNV;
1568 
1569   //=== VK_NV_memory_decompression ===
1570   struct DecompressMemoryRegionNV;
1571   struct PhysicalDeviceMemoryDecompressionFeaturesNV;
1572   struct PhysicalDeviceMemoryDecompressionPropertiesNV;
1573 
1574   //=== VK_NV_device_generated_commands_compute ===
1575   struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
1576   struct ComputePipelineIndirectBufferInfoNV;
1577   struct PipelineIndirectDeviceAddressInfoNV;
1578   struct BindPipelineIndirectCommandNV;
1579 
1580   //=== VK_NV_linear_color_attachment ===
1581   struct PhysicalDeviceLinearColorAttachmentFeaturesNV;
1582 
1583   //=== VK_KHR_shader_maximal_reconvergence ===
1584   struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
1585 
1586   //=== VK_EXT_image_compression_control_swapchain ===
1587   struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
1588 
1589   //=== VK_QCOM_image_processing ===
1590   struct ImageViewSampleWeightCreateInfoQCOM;
1591   struct PhysicalDeviceImageProcessingFeaturesQCOM;
1592   struct PhysicalDeviceImageProcessingPropertiesQCOM;
1593 
1594   //=== VK_EXT_nested_command_buffer ===
1595   struct PhysicalDeviceNestedCommandBufferFeaturesEXT;
1596   struct PhysicalDeviceNestedCommandBufferPropertiesEXT;
1597 
1598   //=== VK_EXT_external_memory_acquire_unmodified ===
1599   struct ExternalMemoryAcquireUnmodifiedEXT;
1600 
1601   //=== VK_EXT_extended_dynamic_state3 ===
1602   struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;
1603   struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;
1604   struct ColorBlendEquationEXT;
1605   struct ColorBlendAdvancedEXT;
1606 
1607   //=== VK_EXT_subpass_merge_feedback ===
1608   struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
1609   struct RenderPassCreationControlEXT;
1610   struct RenderPassCreationFeedbackInfoEXT;
1611   struct RenderPassCreationFeedbackCreateInfoEXT;
1612   struct RenderPassSubpassFeedbackInfoEXT;
1613   struct RenderPassSubpassFeedbackCreateInfoEXT;
1614 
1615   //=== VK_LUNARG_direct_driver_loading ===
1616   struct DirectDriverLoadingInfoLUNARG;
1617   struct DirectDriverLoadingListLUNARG;
1618 
1619   //=== VK_EXT_shader_module_identifier ===
1620   struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
1621   struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
1622   struct PipelineShaderStageModuleIdentifierCreateInfoEXT;
1623   struct ShaderModuleIdentifierEXT;
1624 
1625   //=== VK_EXT_rasterization_order_attachment_access ===
1626   struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1627   using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1628 
1629   //=== VK_NV_optical_flow ===
1630   struct PhysicalDeviceOpticalFlowFeaturesNV;
1631   struct PhysicalDeviceOpticalFlowPropertiesNV;
1632   struct OpticalFlowImageFormatInfoNV;
1633   struct OpticalFlowImageFormatPropertiesNV;
1634   struct OpticalFlowSessionCreateInfoNV;
1635   struct OpticalFlowSessionCreatePrivateDataInfoNV;
1636   struct OpticalFlowExecuteInfoNV;
1637 
1638   //=== VK_EXT_legacy_dithering ===
1639   struct PhysicalDeviceLegacyDitheringFeaturesEXT;
1640 
1641   //=== VK_EXT_pipeline_protected_access ===
1642   struct PhysicalDevicePipelineProtectedAccessFeaturesEXT;
1643 
1644 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
1645   //=== VK_ANDROID_external_format_resolve ===
1646   struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;
1647   struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;
1648   struct AndroidHardwareBufferFormatResolvePropertiesANDROID;
1649 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1650 
1651   //=== VK_KHR_maintenance5 ===
1652   struct PhysicalDeviceMaintenance5FeaturesKHR;
1653   struct PhysicalDeviceMaintenance5PropertiesKHR;
1654   struct RenderingAreaInfoKHR;
1655   struct DeviceImageSubresourceInfoKHR;
1656   struct ImageSubresource2KHR;
1657   using ImageSubresource2EXT = ImageSubresource2KHR;
1658   struct SubresourceLayout2KHR;
1659   using SubresourceLayout2EXT = SubresourceLayout2KHR;
1660   struct PipelineCreateFlags2CreateInfoKHR;
1661   struct BufferUsageFlags2CreateInfoKHR;
1662 
1663   //=== VK_KHR_ray_tracing_position_fetch ===
1664   struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
1665 
1666   //=== VK_EXT_shader_object ===
1667   struct PhysicalDeviceShaderObjectFeaturesEXT;
1668   struct PhysicalDeviceShaderObjectPropertiesEXT;
1669   struct ShaderCreateInfoEXT;
1670 
1671   //=== VK_QCOM_tile_properties ===
1672   struct PhysicalDeviceTilePropertiesFeaturesQCOM;
1673   struct TilePropertiesQCOM;
1674 
1675   //=== VK_SEC_amigo_profiling ===
1676   struct PhysicalDeviceAmigoProfilingFeaturesSEC;
1677   struct AmigoProfilingSubmitInfoSEC;
1678 
1679   //=== VK_QCOM_multiview_per_view_viewports ===
1680   struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
1681 
1682   //=== VK_NV_ray_tracing_invocation_reorder ===
1683   struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
1684   struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
1685 
1686   //=== VK_NV_extended_sparse_address_space ===
1687   struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
1688   struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
1689 
1690   //=== VK_EXT_mutable_descriptor_type ===
1691   struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1692   using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1693   struct MutableDescriptorTypeListEXT;
1694   using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;
1695   struct MutableDescriptorTypeCreateInfoEXT;
1696   using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
1697 
1698   //=== VK_EXT_legacy_vertex_attributes ===
1699   struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT;
1700   struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT;
1701 
1702   //=== VK_EXT_layer_settings ===
1703   struct LayerSettingsCreateInfoEXT;
1704   struct LayerSettingEXT;
1705 
1706   //=== VK_ARM_shader_core_builtins ===
1707   struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
1708   struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
1709 
1710   //=== VK_EXT_pipeline_library_group_handles ===
1711   struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
1712 
1713   //=== VK_EXT_dynamic_rendering_unused_attachments ===
1714   struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
1715 
1716   //=== VK_NV_low_latency2 ===
1717   struct LatencySleepModeInfoNV;
1718   struct LatencySleepInfoNV;
1719   struct SetLatencyMarkerInfoNV;
1720   struct GetLatencyMarkerInfoNV;
1721   struct LatencyTimingsFrameReportNV;
1722   struct LatencySubmissionPresentIdNV;
1723   struct SwapchainLatencyCreateInfoNV;
1724   struct OutOfBandQueueTypeInfoNV;
1725   struct LatencySurfaceCapabilitiesNV;
1726 
1727   //=== VK_KHR_cooperative_matrix ===
1728   struct CooperativeMatrixPropertiesKHR;
1729   struct PhysicalDeviceCooperativeMatrixFeaturesKHR;
1730   struct PhysicalDeviceCooperativeMatrixPropertiesKHR;
1731 
1732   //=== VK_QCOM_multiview_per_view_render_areas ===
1733   struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
1734   struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
1735 
1736   //=== VK_KHR_video_decode_av1 ===
1737   struct VideoDecodeAV1ProfileInfoKHR;
1738   struct VideoDecodeAV1CapabilitiesKHR;
1739   struct VideoDecodeAV1SessionParametersCreateInfoKHR;
1740   struct VideoDecodeAV1PictureInfoKHR;
1741   struct VideoDecodeAV1DpbSlotInfoKHR;
1742 
1743   //=== VK_KHR_video_maintenance1 ===
1744   struct PhysicalDeviceVideoMaintenance1FeaturesKHR;
1745   struct VideoInlineQueryInfoKHR;
1746 
1747   //=== VK_NV_per_stage_descriptor_set ===
1748   struct PhysicalDevicePerStageDescriptorSetFeaturesNV;
1749 
1750   //=== VK_QCOM_image_processing2 ===
1751   struct PhysicalDeviceImageProcessing2FeaturesQCOM;
1752   struct PhysicalDeviceImageProcessing2PropertiesQCOM;
1753   struct SamplerBlockMatchWindowCreateInfoQCOM;
1754 
1755   //=== VK_QCOM_filter_cubic_weights ===
1756   struct PhysicalDeviceCubicWeightsFeaturesQCOM;
1757   struct SamplerCubicWeightsCreateInfoQCOM;
1758   struct BlitImageCubicWeightsInfoQCOM;
1759 
1760   //=== VK_QCOM_ycbcr_degamma ===
1761   struct PhysicalDeviceYcbcrDegammaFeaturesQCOM;
1762   struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
1763 
1764   //=== VK_QCOM_filter_cubic_clamp ===
1765   struct PhysicalDeviceCubicClampFeaturesQCOM;
1766 
1767   //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
1768   struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
1769 
1770   //=== VK_KHR_vertex_attribute_divisor ===
1771   struct PhysicalDeviceVertexAttributeDivisorPropertiesKHR;
1772   struct VertexInputBindingDivisorDescriptionKHR;
1773   using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescriptionKHR;
1774   struct PipelineVertexInputDivisorStateCreateInfoKHR;
1775   using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfoKHR;
1776   struct PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
1777   using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
1778 
1779   //=== VK_KHR_shader_float_controls2 ===
1780   struct PhysicalDeviceShaderFloatControls2FeaturesKHR;
1781 
1782 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1783   //=== VK_QNX_external_memory_screen_buffer ===
1784   struct ScreenBufferPropertiesQNX;
1785   struct ScreenBufferFormatPropertiesQNX;
1786   struct ImportScreenBufferInfoQNX;
1787   struct ExternalFormatQNX;
1788   struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
1789 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1790 
1791   //=== VK_MSFT_layered_driver ===
1792   struct PhysicalDeviceLayeredDriverPropertiesMSFT;
1793 
1794   //=== VK_KHR_index_type_uint8 ===
1795   struct PhysicalDeviceIndexTypeUint8FeaturesKHR;
1796   using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8FeaturesKHR;
1797 
1798   //=== VK_KHR_line_rasterization ===
1799   struct PhysicalDeviceLineRasterizationFeaturesKHR;
1800   using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeaturesKHR;
1801   struct PhysicalDeviceLineRasterizationPropertiesKHR;
1802   using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationPropertiesKHR;
1803   struct PipelineRasterizationLineStateCreateInfoKHR;
1804   using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfoKHR;
1805 
1806   //=== VK_KHR_calibrated_timestamps ===
1807   struct CalibratedTimestampInfoKHR;
1808   using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;
1809 
1810   //=== VK_KHR_shader_expect_assume ===
1811   struct PhysicalDeviceShaderExpectAssumeFeaturesKHR;
1812 
1813   //=== VK_KHR_maintenance6 ===
1814   struct PhysicalDeviceMaintenance6FeaturesKHR;
1815   struct PhysicalDeviceMaintenance6PropertiesKHR;
1816   struct BindMemoryStatusKHR;
1817   struct BindDescriptorSetsInfoKHR;
1818   struct PushConstantsInfoKHR;
1819   struct PushDescriptorSetInfoKHR;
1820   struct PushDescriptorSetWithTemplateInfoKHR;
1821   struct SetDescriptorBufferOffsetsInfoEXT;
1822   struct BindDescriptorBufferEmbeddedSamplersInfoEXT;
1823 
1824   //=== VK_NV_descriptor_pool_overallocation ===
1825   struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
1826 
1827   //=== VK_NV_raw_access_chains ===
1828   struct PhysicalDeviceRawAccessChainsFeaturesNV;
1829 
1830   //=== VK_NV_shader_atomic_float16_vector ===
1831   struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
1832 
1833   //=== VK_EXT_shader_replicated_composites ===
1834   struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT;
1835 
1836   //=== VK_NV_ray_tracing_validation ===
1837   struct PhysicalDeviceRayTracingValidationFeaturesNV;
1838 
1839   //=== VK_MESA_image_alignment_control ===
1840   struct PhysicalDeviceImageAlignmentControlFeaturesMESA;
1841   struct PhysicalDeviceImageAlignmentControlPropertiesMESA;
1842   struct ImageAlignmentControlCreateInfoMESA;
1843 
1844   //===================================
1845   //=== HANDLE forward declarations ===
1846   //===================================
1847 
1848   //=== VK_VERSION_1_0 ===
1849   class Instance;
1850   class PhysicalDevice;
1851   class Device;
1852   class Queue;
1853   class DeviceMemory;
1854   class Fence;
1855   class Semaphore;
1856   class Event;
1857   class QueryPool;
1858   class Buffer;
1859   class BufferView;
1860   class Image;
1861   class ImageView;
1862   class ShaderModule;
1863   class PipelineCache;
1864   class Pipeline;
1865   class PipelineLayout;
1866   class Sampler;
1867   class DescriptorPool;
1868   class DescriptorSet;
1869   class DescriptorSetLayout;
1870   class Framebuffer;
1871   class RenderPass;
1872   class CommandPool;
1873   class CommandBuffer;
1874 
1875   //=== VK_VERSION_1_1 ===
1876   class SamplerYcbcrConversion;
1877   class DescriptorUpdateTemplate;
1878 
1879   //=== VK_VERSION_1_3 ===
1880   class PrivateDataSlot;
1881 
1882   //=== VK_KHR_surface ===
1883   class SurfaceKHR;
1884 
1885   //=== VK_KHR_swapchain ===
1886   class SwapchainKHR;
1887 
1888   //=== VK_KHR_display ===
1889   class DisplayKHR;
1890   class DisplayModeKHR;
1891 
1892   //=== VK_EXT_debug_report ===
1893   class DebugReportCallbackEXT;
1894 
1895   //=== VK_KHR_video_queue ===
1896   class VideoSessionKHR;
1897   class VideoSessionParametersKHR;
1898 
1899   //=== VK_NVX_binary_import ===
1900   class CuModuleNVX;
1901   class CuFunctionNVX;
1902 
1903   //=== VK_EXT_debug_utils ===
1904   class DebugUtilsMessengerEXT;
1905 
1906   //=== VK_KHR_acceleration_structure ===
1907   class AccelerationStructureKHR;
1908 
1909   //=== VK_EXT_validation_cache ===
1910   class ValidationCacheEXT;
1911 
1912   //=== VK_NV_ray_tracing ===
1913   class AccelerationStructureNV;
1914 
1915   //=== VK_INTEL_performance_query ===
1916   class PerformanceConfigurationINTEL;
1917 
1918   //=== VK_KHR_deferred_host_operations ===
1919   class DeferredOperationKHR;
1920 
1921   //=== VK_NV_device_generated_commands ===
1922   class IndirectCommandsLayoutNV;
1923 
1924 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1925   //=== VK_NV_cuda_kernel_launch ===
1926   class CudaModuleNV;
1927   class CudaFunctionNV;
1928 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1929 
1930 #if defined( VK_USE_PLATFORM_FUCHSIA )
1931   //=== VK_FUCHSIA_buffer_collection ===
1932   class BufferCollectionFUCHSIA;
1933 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1934 
1935   //=== VK_EXT_opacity_micromap ===
1936   class MicromapEXT;
1937 
1938   //=== VK_NV_optical_flow ===
1939   class OpticalFlowSessionNV;
1940 
1941   //=== VK_EXT_shader_object ===
1942   class ShaderEXT;
1943 
1944 #ifndef VULKAN_HPP_NO_SMART_HANDLE
1945   //======================
1946   //=== UNIQUE HANDLEs ===
1947   //======================
1948 
1949   //=== VK_VERSION_1_0 ===
1950   template <typename Dispatch>
1951   class UniqueHandleTraits<Instance, Dispatch>
1952   {
1953   public:
1954     using deleter = ObjectDestroy<NoParent, Dispatch>;
1955   };
1956 
1957   using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1958 
1959   template <typename Dispatch>
1960   class UniqueHandleTraits<Device, Dispatch>
1961   {
1962   public:
1963     using deleter = ObjectDestroy<NoParent, Dispatch>;
1964   };
1965 
1966   using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1967 
1968   template <typename Dispatch>
1969   class UniqueHandleTraits<DeviceMemory, Dispatch>
1970   {
1971   public:
1972     using deleter = ObjectFree<Device, Dispatch>;
1973   };
1974 
1975   using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1976 
1977   template <typename Dispatch>
1978   class UniqueHandleTraits<Fence, Dispatch>
1979   {
1980   public:
1981     using deleter = ObjectDestroy<Device, Dispatch>;
1982   };
1983 
1984   using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1985 
1986   template <typename Dispatch>
1987   class UniqueHandleTraits<Semaphore, Dispatch>
1988   {
1989   public:
1990     using deleter = ObjectDestroy<Device, Dispatch>;
1991   };
1992 
1993   using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
1994 
1995   template <typename Dispatch>
1996   class UniqueHandleTraits<Event, Dispatch>
1997   {
1998   public:
1999     using deleter = ObjectDestroy<Device, Dispatch>;
2000   };
2001 
2002   using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2003 
2004   template <typename Dispatch>
2005   class UniqueHandleTraits<QueryPool, Dispatch>
2006   {
2007   public:
2008     using deleter = ObjectDestroy<Device, Dispatch>;
2009   };
2010 
2011   using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2012 
2013   template <typename Dispatch>
2014   class UniqueHandleTraits<Buffer, Dispatch>
2015   {
2016   public:
2017     using deleter = ObjectDestroy<Device, Dispatch>;
2018   };
2019 
2020   using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2021 
2022   template <typename Dispatch>
2023   class UniqueHandleTraits<BufferView, Dispatch>
2024   {
2025   public:
2026     using deleter = ObjectDestroy<Device, Dispatch>;
2027   };
2028 
2029   using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2030 
2031   template <typename Dispatch>
2032   class UniqueHandleTraits<Image, Dispatch>
2033   {
2034   public:
2035     using deleter = ObjectDestroy<Device, Dispatch>;
2036   };
2037 
2038   using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2039 
2040   template <typename Dispatch>
2041   class UniqueHandleTraits<ImageView, Dispatch>
2042   {
2043   public:
2044     using deleter = ObjectDestroy<Device, Dispatch>;
2045   };
2046 
2047   using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2048 
2049   template <typename Dispatch>
2050   class UniqueHandleTraits<ShaderModule, Dispatch>
2051   {
2052   public:
2053     using deleter = ObjectDestroy<Device, Dispatch>;
2054   };
2055 
2056   using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2057 
2058   template <typename Dispatch>
2059   class UniqueHandleTraits<PipelineCache, Dispatch>
2060   {
2061   public:
2062     using deleter = ObjectDestroy<Device, Dispatch>;
2063   };
2064 
2065   using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2066 
2067   template <typename Dispatch>
2068   class UniqueHandleTraits<Pipeline, Dispatch>
2069   {
2070   public:
2071     using deleter = ObjectDestroy<Device, Dispatch>;
2072   };
2073 
2074   using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2075 
2076   template <typename Dispatch>
2077   class UniqueHandleTraits<PipelineLayout, Dispatch>
2078   {
2079   public:
2080     using deleter = ObjectDestroy<Device, Dispatch>;
2081   };
2082 
2083   using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2084 
2085   template <typename Dispatch>
2086   class UniqueHandleTraits<Sampler, Dispatch>
2087   {
2088   public:
2089     using deleter = ObjectDestroy<Device, Dispatch>;
2090   };
2091 
2092   using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2093 
2094   template <typename Dispatch>
2095   class UniqueHandleTraits<DescriptorPool, Dispatch>
2096   {
2097   public:
2098     using deleter = ObjectDestroy<Device, Dispatch>;
2099   };
2100 
2101   using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2102 
2103   template <typename Dispatch>
2104   class UniqueHandleTraits<DescriptorSet, Dispatch>
2105   {
2106   public:
2107     using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
2108   };
2109 
2110   using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2111 
2112   template <typename Dispatch>
2113   class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
2114   {
2115   public:
2116     using deleter = ObjectDestroy<Device, Dispatch>;
2117   };
2118 
2119   using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2120 
2121   template <typename Dispatch>
2122   class UniqueHandleTraits<Framebuffer, Dispatch>
2123   {
2124   public:
2125     using deleter = ObjectDestroy<Device, Dispatch>;
2126   };
2127 
2128   using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2129 
2130   template <typename Dispatch>
2131   class UniqueHandleTraits<RenderPass, Dispatch>
2132   {
2133   public:
2134     using deleter = ObjectDestroy<Device, Dispatch>;
2135   };
2136 
2137   using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2138 
2139   template <typename Dispatch>
2140   class UniqueHandleTraits<CommandPool, Dispatch>
2141   {
2142   public:
2143     using deleter = ObjectDestroy<Device, Dispatch>;
2144   };
2145 
2146   using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2147 
2148   template <typename Dispatch>
2149   class UniqueHandleTraits<CommandBuffer, Dispatch>
2150   {
2151   public:
2152     using deleter = PoolFree<Device, CommandPool, Dispatch>;
2153   };
2154 
2155   using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2156 
2157   //=== VK_VERSION_1_1 ===
2158   template <typename Dispatch>
2159   class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
2160   {
2161   public:
2162     using deleter = ObjectDestroy<Device, Dispatch>;
2163   };
2164 
2165   using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2166   using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2167 
2168   template <typename Dispatch>
2169   class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
2170   {
2171   public:
2172     using deleter = ObjectDestroy<Device, Dispatch>;
2173   };
2174 
2175   using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2176   using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2177 
2178   //=== VK_VERSION_1_3 ===
2179   template <typename Dispatch>
2180   class UniqueHandleTraits<PrivateDataSlot, Dispatch>
2181   {
2182   public:
2183     using deleter = ObjectDestroy<Device, Dispatch>;
2184   };
2185 
2186   using UniquePrivateDataSlot    = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2187   using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2188 
2189   //=== VK_KHR_surface ===
2190   template <typename Dispatch>
2191   class UniqueHandleTraits<SurfaceKHR, Dispatch>
2192   {
2193   public:
2194     using deleter = ObjectDestroy<Instance, Dispatch>;
2195   };
2196 
2197   using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2198 
2199   //=== VK_KHR_swapchain ===
2200   template <typename Dispatch>
2201   class UniqueHandleTraits<SwapchainKHR, Dispatch>
2202   {
2203   public:
2204     using deleter = ObjectDestroy<Device, Dispatch>;
2205   };
2206 
2207   using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2208 
2209   //=== VK_KHR_display ===
2210   template <typename Dispatch>
2211   class UniqueHandleTraits<DisplayKHR, Dispatch>
2212   {
2213   public:
2214     using deleter = ObjectDestroy<PhysicalDevice, Dispatch>;
2215   };
2216 
2217   using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2218 
2219   //=== VK_EXT_debug_report ===
2220   template <typename Dispatch>
2221   class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
2222   {
2223   public:
2224     using deleter = ObjectDestroy<Instance, Dispatch>;
2225   };
2226 
2227   using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2228 
2229   //=== VK_KHR_video_queue ===
2230   template <typename Dispatch>
2231   class UniqueHandleTraits<VideoSessionKHR, Dispatch>
2232   {
2233   public:
2234     using deleter = ObjectDestroy<Device, Dispatch>;
2235   };
2236 
2237   using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2238 
2239   template <typename Dispatch>
2240   class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
2241   {
2242   public:
2243     using deleter = ObjectDestroy<Device, Dispatch>;
2244   };
2245 
2246   using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2247 
2248   //=== VK_NVX_binary_import ===
2249   template <typename Dispatch>
2250   class UniqueHandleTraits<CuModuleNVX, Dispatch>
2251   {
2252   public:
2253     using deleter = ObjectDestroy<Device, Dispatch>;
2254   };
2255 
2256   using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2257 
2258   template <typename Dispatch>
2259   class UniqueHandleTraits<CuFunctionNVX, Dispatch>
2260   {
2261   public:
2262     using deleter = ObjectDestroy<Device, Dispatch>;
2263   };
2264 
2265   using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2266 
2267   //=== VK_EXT_debug_utils ===
2268   template <typename Dispatch>
2269   class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
2270   {
2271   public:
2272     using deleter = ObjectDestroy<Instance, Dispatch>;
2273   };
2274 
2275   using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2276 
2277   //=== VK_KHR_acceleration_structure ===
2278   template <typename Dispatch>
2279   class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
2280   {
2281   public:
2282     using deleter = ObjectDestroy<Device, Dispatch>;
2283   };
2284 
2285   using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2286 
2287   //=== VK_EXT_validation_cache ===
2288   template <typename Dispatch>
2289   class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
2290   {
2291   public:
2292     using deleter = ObjectDestroy<Device, Dispatch>;
2293   };
2294 
2295   using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2296 
2297   //=== VK_NV_ray_tracing ===
2298   template <typename Dispatch>
2299   class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
2300   {
2301   public:
2302     using deleter = ObjectDestroy<Device, Dispatch>;
2303   };
2304 
2305   using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2306 
2307   //=== VK_INTEL_performance_query ===
2308   template <typename Dispatch>
2309   class UniqueHandleTraits<PerformanceConfigurationINTEL, Dispatch>
2310   {
2311   public:
2312     using deleter = ObjectDestroy<Device, Dispatch>;
2313   };
2314 
2315   using UniquePerformanceConfigurationINTEL = UniqueHandle<PerformanceConfigurationINTEL, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2316 
2317   //=== VK_KHR_deferred_host_operations ===
2318   template <typename Dispatch>
2319   class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
2320   {
2321   public:
2322     using deleter = ObjectDestroy<Device, Dispatch>;
2323   };
2324 
2325   using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2326 
2327   //=== VK_NV_device_generated_commands ===
2328   template <typename Dispatch>
2329   class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
2330   {
2331   public:
2332     using deleter = ObjectDestroy<Device, Dispatch>;
2333   };
2334 
2335   using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2336 
2337 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
2338   //=== VK_NV_cuda_kernel_launch ===
2339   template <typename Dispatch>
2340   class UniqueHandleTraits<CudaModuleNV, Dispatch>
2341   {
2342   public:
2343     using deleter = ObjectDestroy<Device, Dispatch>;
2344   };
2345 
2346   using UniqueCudaModuleNV = UniqueHandle<CudaModuleNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2347 
2348   template <typename Dispatch>
2349   class UniqueHandleTraits<CudaFunctionNV, Dispatch>
2350   {
2351   public:
2352     using deleter = ObjectDestroy<Device, Dispatch>;
2353   };
2354 
2355   using UniqueCudaFunctionNV = UniqueHandle<CudaFunctionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2356 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
2357 
2358 #  if defined( VK_USE_PLATFORM_FUCHSIA )
2359   //=== VK_FUCHSIA_buffer_collection ===
2360   template <typename Dispatch>
2361   class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
2362   {
2363   public:
2364     using deleter = ObjectDestroy<Device, Dispatch>;
2365   };
2366 
2367   using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2368 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
2369 
2370   //=== VK_EXT_opacity_micromap ===
2371   template <typename Dispatch>
2372   class UniqueHandleTraits<MicromapEXT, Dispatch>
2373   {
2374   public:
2375     using deleter = ObjectDestroy<Device, Dispatch>;
2376   };
2377 
2378   using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2379 
2380   //=== VK_NV_optical_flow ===
2381   template <typename Dispatch>
2382   class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
2383   {
2384   public:
2385     using deleter = ObjectDestroy<Device, Dispatch>;
2386   };
2387 
2388   using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2389 
2390   //=== VK_EXT_shader_object ===
2391   template <typename Dispatch>
2392   class UniqueHandleTraits<ShaderEXT, Dispatch>
2393   {
2394   public:
2395     using deleter = ObjectDestroy<Device, Dispatch>;
2396   };
2397 
2398   using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2399 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
2400 
2401   //===============
2402   //=== HANDLEs ===
2403   //===============
2404 
2405   template <typename Type>
2406   struct isVulkanHandleType
2407   {
2408     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
2409   };
2410 
2411   class SurfaceKHR
2412   {
2413   public:
2414     using CType      = VkSurfaceKHR;
2415     using NativeType = VkSurfaceKHR;
2416 
2417     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
2418     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2419       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
2420 
2421   public:
2422     SurfaceKHR()                                     = default;
2423     SurfaceKHR( SurfaceKHR const & rhs )             = default;
2424     SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default;
2425     SurfaceKHR( SurfaceKHR && rhs )                  = default;
2426     SurfaceKHR & operator=( SurfaceKHR && rhs )      = default;
2427 
SurfaceKHR(std::nullptr_t)2428     VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2429 
SurfaceKHR(VkSurfaceKHR surfaceKHR)2430     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}
2431 
2432 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSurfaceKHR surfaceKHR)2433     SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
2434     {
2435       m_surfaceKHR = surfaceKHR;
2436       return *this;
2437     }
2438 #endif
2439 
operator =(std::nullptr_t)2440     SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2441     {
2442       m_surfaceKHR = {};
2443       return *this;
2444     }
2445 
2446 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2447     auto operator<=>( SurfaceKHR const & ) const = default;
2448 #else
operator ==(SurfaceKHR const & rhs) const2449     bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2450     {
2451       return m_surfaceKHR == rhs.m_surfaceKHR;
2452     }
2453 
operator !=(SurfaceKHR const & rhs) const2454     bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2455     {
2456       return m_surfaceKHR != rhs.m_surfaceKHR;
2457     }
2458 
operator <(SurfaceKHR const & rhs) const2459     bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2460     {
2461       return m_surfaceKHR < rhs.m_surfaceKHR;
2462     }
2463 #endif
2464 
operator VkSurfaceKHR() const2465     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
2466     {
2467       return m_surfaceKHR;
2468     }
2469 
operator bool() const2470     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2471     {
2472       return m_surfaceKHR != VK_NULL_HANDLE;
2473     }
2474 
operator !() const2475     bool operator!() const VULKAN_HPP_NOEXCEPT
2476     {
2477       return m_surfaceKHR == VK_NULL_HANDLE;
2478     }
2479 
2480   private:
2481     VkSurfaceKHR m_surfaceKHR = {};
2482   };
2483 
2484   template <>
2485   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
2486   {
2487     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2488   };
2489 
2490   template <>
2491   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
2492   {
2493     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2494   };
2495 
2496 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2497   template <>
2498   struct CppType<VkSurfaceKHR, VK_NULL_HANDLE>
2499   {
2500     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2501   };
2502 #endif
2503 
2504   template <>
2505   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
2506   {
2507     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2508   };
2509 
2510   class DebugReportCallbackEXT
2511   {
2512   public:
2513     using CType      = VkDebugReportCallbackEXT;
2514     using NativeType = VkDebugReportCallbackEXT;
2515 
2516     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
2517     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2518       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
2519 
2520   public:
2521     DebugReportCallbackEXT()                                                 = default;
2522     DebugReportCallbackEXT( DebugReportCallbackEXT const & rhs )             = default;
2523     DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & rhs ) = default;
2524     DebugReportCallbackEXT( DebugReportCallbackEXT && rhs )                  = default;
2525     DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs )      = default;
2526 
DebugReportCallbackEXT(std::nullptr_t)2527     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2528 
DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)2529     VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
2530       : m_debugReportCallbackEXT( debugReportCallbackEXT )
2531     {
2532     }
2533 
2534 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDebugReportCallbackEXT debugReportCallbackEXT)2535     DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
2536     {
2537       m_debugReportCallbackEXT = debugReportCallbackEXT;
2538       return *this;
2539     }
2540 #endif
2541 
operator =(std::nullptr_t)2542     DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2543     {
2544       m_debugReportCallbackEXT = {};
2545       return *this;
2546     }
2547 
2548 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2549     auto operator<=>( DebugReportCallbackEXT const & ) const = default;
2550 #else
operator ==(DebugReportCallbackEXT const & rhs) const2551     bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2552     {
2553       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
2554     }
2555 
operator !=(DebugReportCallbackEXT const & rhs) const2556     bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2557     {
2558       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
2559     }
2560 
operator <(DebugReportCallbackEXT const & rhs) const2561     bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2562     {
2563       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
2564     }
2565 #endif
2566 
operator VkDebugReportCallbackEXT() const2567     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
2568     {
2569       return m_debugReportCallbackEXT;
2570     }
2571 
operator bool() const2572     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2573     {
2574       return m_debugReportCallbackEXT != VK_NULL_HANDLE;
2575     }
2576 
operator !() const2577     bool operator!() const VULKAN_HPP_NOEXCEPT
2578     {
2579       return m_debugReportCallbackEXT == VK_NULL_HANDLE;
2580     }
2581 
2582   private:
2583     VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
2584   };
2585 
2586   template <>
2587   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
2588   {
2589     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2590   };
2591 
2592   template <>
2593   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
2594   {
2595     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2596   };
2597 
2598 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2599   template <>
2600   struct CppType<VkDebugReportCallbackEXT, VK_NULL_HANDLE>
2601   {
2602     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2603   };
2604 #endif
2605 
2606   template <>
2607   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
2608   {
2609     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2610   };
2611 
2612   class DebugUtilsMessengerEXT
2613   {
2614   public:
2615     using CType      = VkDebugUtilsMessengerEXT;
2616     using NativeType = VkDebugUtilsMessengerEXT;
2617 
2618     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
2619     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2620       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2621 
2622   public:
2623     DebugUtilsMessengerEXT()                                                 = default;
2624     DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs )             = default;
2625     DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default;
2626     DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs )                  = default;
2627     DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs )      = default;
2628 
DebugUtilsMessengerEXT(std::nullptr_t)2629     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2630 
DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)2631     VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
2632       : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
2633     {
2634     }
2635 
2636 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)2637     DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
2638     {
2639       m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
2640       return *this;
2641     }
2642 #endif
2643 
operator =(std::nullptr_t)2644     DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2645     {
2646       m_debugUtilsMessengerEXT = {};
2647       return *this;
2648     }
2649 
2650 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2651     auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
2652 #else
operator ==(DebugUtilsMessengerEXT const & rhs) const2653     bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2654     {
2655       return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
2656     }
2657 
operator !=(DebugUtilsMessengerEXT const & rhs) const2658     bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2659     {
2660       return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
2661     }
2662 
operator <(DebugUtilsMessengerEXT const & rhs) const2663     bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2664     {
2665       return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
2666     }
2667 #endif
2668 
operator VkDebugUtilsMessengerEXT() const2669     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
2670     {
2671       return m_debugUtilsMessengerEXT;
2672     }
2673 
operator bool() const2674     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2675     {
2676       return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
2677     }
2678 
operator !() const2679     bool operator!() const VULKAN_HPP_NOEXCEPT
2680     {
2681       return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
2682     }
2683 
2684   private:
2685     VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
2686   };
2687 
2688   template <>
2689   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
2690   {
2691     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
2692   };
2693 
2694 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2695   template <>
2696   struct CppType<VkDebugUtilsMessengerEXT, VK_NULL_HANDLE>
2697   {
2698     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
2699   };
2700 #endif
2701 
2702   template <>
2703   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
2704   {
2705     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2706   };
2707 
2708   class DisplayKHR
2709   {
2710   public:
2711     using CType      = VkDisplayKHR;
2712     using NativeType = VkDisplayKHR;
2713 
2714     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
2715     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2716       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
2717 
2718   public:
2719     DisplayKHR()                                     = default;
2720     DisplayKHR( DisplayKHR const & rhs )             = default;
2721     DisplayKHR & operator=( DisplayKHR const & rhs ) = default;
2722     DisplayKHR( DisplayKHR && rhs )                  = default;
2723     DisplayKHR & operator=( DisplayKHR && rhs )      = default;
2724 
DisplayKHR(std::nullptr_t)2725     VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2726 
DisplayKHR(VkDisplayKHR displayKHR)2727     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
2728 
2729 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDisplayKHR displayKHR)2730     DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
2731     {
2732       m_displayKHR = displayKHR;
2733       return *this;
2734     }
2735 #endif
2736 
operator =(std::nullptr_t)2737     DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2738     {
2739       m_displayKHR = {};
2740       return *this;
2741     }
2742 
2743 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2744     auto operator<=>( DisplayKHR const & ) const = default;
2745 #else
operator ==(DisplayKHR const & rhs) const2746     bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2747     {
2748       return m_displayKHR == rhs.m_displayKHR;
2749     }
2750 
operator !=(DisplayKHR const & rhs) const2751     bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2752     {
2753       return m_displayKHR != rhs.m_displayKHR;
2754     }
2755 
operator <(DisplayKHR const & rhs) const2756     bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2757     {
2758       return m_displayKHR < rhs.m_displayKHR;
2759     }
2760 #endif
2761 
operator VkDisplayKHR() const2762     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
2763     {
2764       return m_displayKHR;
2765     }
2766 
operator bool() const2767     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2768     {
2769       return m_displayKHR != VK_NULL_HANDLE;
2770     }
2771 
operator !() const2772     bool operator!() const VULKAN_HPP_NOEXCEPT
2773     {
2774       return m_displayKHR == VK_NULL_HANDLE;
2775     }
2776 
2777   private:
2778     VkDisplayKHR m_displayKHR = {};
2779   };
2780 
2781   template <>
2782   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
2783   {
2784     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2785   };
2786 
2787   template <>
2788   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
2789   {
2790     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2791   };
2792 
2793 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2794   template <>
2795   struct CppType<VkDisplayKHR, VK_NULL_HANDLE>
2796   {
2797     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2798   };
2799 #endif
2800 
2801   template <>
2802   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
2803   {
2804     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2805   };
2806 
2807   class SwapchainKHR
2808   {
2809   public:
2810     using CType      = VkSwapchainKHR;
2811     using NativeType = VkSwapchainKHR;
2812 
2813     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
2814     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2815       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
2816 
2817   public:
2818     SwapchainKHR()                                       = default;
2819     SwapchainKHR( SwapchainKHR const & rhs )             = default;
2820     SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default;
2821     SwapchainKHR( SwapchainKHR && rhs )                  = default;
2822     SwapchainKHR & operator=( SwapchainKHR && rhs )      = default;
2823 
SwapchainKHR(std::nullptr_t)2824     VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2825 
SwapchainKHR(VkSwapchainKHR swapchainKHR)2826     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}
2827 
2828 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSwapchainKHR swapchainKHR)2829     SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
2830     {
2831       m_swapchainKHR = swapchainKHR;
2832       return *this;
2833     }
2834 #endif
2835 
operator =(std::nullptr_t)2836     SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2837     {
2838       m_swapchainKHR = {};
2839       return *this;
2840     }
2841 
2842 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2843     auto operator<=>( SwapchainKHR const & ) const = default;
2844 #else
operator ==(SwapchainKHR const & rhs) const2845     bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2846     {
2847       return m_swapchainKHR == rhs.m_swapchainKHR;
2848     }
2849 
operator !=(SwapchainKHR const & rhs) const2850     bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2851     {
2852       return m_swapchainKHR != rhs.m_swapchainKHR;
2853     }
2854 
operator <(SwapchainKHR const & rhs) const2855     bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2856     {
2857       return m_swapchainKHR < rhs.m_swapchainKHR;
2858     }
2859 #endif
2860 
operator VkSwapchainKHR() const2861     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
2862     {
2863       return m_swapchainKHR;
2864     }
2865 
operator bool() const2866     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2867     {
2868       return m_swapchainKHR != VK_NULL_HANDLE;
2869     }
2870 
operator !() const2871     bool operator!() const VULKAN_HPP_NOEXCEPT
2872     {
2873       return m_swapchainKHR == VK_NULL_HANDLE;
2874     }
2875 
2876   private:
2877     VkSwapchainKHR m_swapchainKHR = {};
2878   };
2879 
2880   template <>
2881   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
2882   {
2883     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2884   };
2885 
2886   template <>
2887   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
2888   {
2889     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2890   };
2891 
2892 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2893   template <>
2894   struct CppType<VkSwapchainKHR, VK_NULL_HANDLE>
2895   {
2896     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2897   };
2898 #endif
2899 
2900   template <>
2901   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
2902   {
2903     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2904   };
2905 
2906   class Semaphore
2907   {
2908   public:
2909     using CType      = VkSemaphore;
2910     using NativeType = VkSemaphore;
2911 
2912     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
2913     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2914       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
2915 
2916   public:
2917     Semaphore()                                    = default;
2918     Semaphore( Semaphore const & rhs )             = default;
2919     Semaphore & operator=( Semaphore const & rhs ) = default;
2920     Semaphore( Semaphore && rhs )                  = default;
2921     Semaphore & operator=( Semaphore && rhs )      = default;
2922 
Semaphore(std::nullptr_t)2923     VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2924 
Semaphore(VkSemaphore semaphore)2925     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
2926 
2927 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSemaphore semaphore)2928     Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
2929     {
2930       m_semaphore = semaphore;
2931       return *this;
2932     }
2933 #endif
2934 
operator =(std::nullptr_t)2935     Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2936     {
2937       m_semaphore = {};
2938       return *this;
2939     }
2940 
2941 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2942     auto operator<=>( Semaphore const & ) const = default;
2943 #else
operator ==(Semaphore const & rhs) const2944     bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2945     {
2946       return m_semaphore == rhs.m_semaphore;
2947     }
2948 
operator !=(Semaphore const & rhs) const2949     bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2950     {
2951       return m_semaphore != rhs.m_semaphore;
2952     }
2953 
operator <(Semaphore const & rhs) const2954     bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2955     {
2956       return m_semaphore < rhs.m_semaphore;
2957     }
2958 #endif
2959 
operator VkSemaphore() const2960     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
2961     {
2962       return m_semaphore;
2963     }
2964 
operator bool() const2965     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2966     {
2967       return m_semaphore != VK_NULL_HANDLE;
2968     }
2969 
operator !() const2970     bool operator!() const VULKAN_HPP_NOEXCEPT
2971     {
2972       return m_semaphore == VK_NULL_HANDLE;
2973     }
2974 
2975   private:
2976     VkSemaphore m_semaphore = {};
2977   };
2978 
2979   template <>
2980   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
2981   {
2982     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2983   };
2984 
2985   template <>
2986   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
2987   {
2988     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2989   };
2990 
2991 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2992   template <>
2993   struct CppType<VkSemaphore, VK_NULL_HANDLE>
2994   {
2995     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2996   };
2997 #endif
2998 
2999   template <>
3000   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
3001   {
3002     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3003   };
3004 
3005   class Fence
3006   {
3007   public:
3008     using CType      = VkFence;
3009     using NativeType = VkFence;
3010 
3011     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;
3012     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3013       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
3014 
3015   public:
3016     Fence()                                = default;
3017     Fence( Fence const & rhs )             = default;
3018     Fence & operator=( Fence const & rhs ) = default;
3019     Fence( Fence && rhs )                  = default;
3020     Fence & operator=( Fence && rhs )      = default;
3021 
Fence(std::nullptr_t)3022     VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3023 
Fence(VkFence fence)3024     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
3025 
3026 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkFence fence)3027     Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
3028     {
3029       m_fence = fence;
3030       return *this;
3031     }
3032 #endif
3033 
operator =(std::nullptr_t)3034     Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3035     {
3036       m_fence = {};
3037       return *this;
3038     }
3039 
3040 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3041     auto operator<=>( Fence const & ) const = default;
3042 #else
operator ==(Fence const & rhs) const3043     bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
3044     {
3045       return m_fence == rhs.m_fence;
3046     }
3047 
operator !=(Fence const & rhs) const3048     bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
3049     {
3050       return m_fence != rhs.m_fence;
3051     }
3052 
operator <(Fence const & rhs) const3053     bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
3054     {
3055       return m_fence < rhs.m_fence;
3056     }
3057 #endif
3058 
operator VkFence() const3059     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
3060     {
3061       return m_fence;
3062     }
3063 
operator bool() const3064     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3065     {
3066       return m_fence != VK_NULL_HANDLE;
3067     }
3068 
operator !() const3069     bool operator!() const VULKAN_HPP_NOEXCEPT
3070     {
3071       return m_fence == VK_NULL_HANDLE;
3072     }
3073 
3074   private:
3075     VkFence m_fence = {};
3076   };
3077 
3078   template <>
3079   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
3080   {
3081     using Type = VULKAN_HPP_NAMESPACE::Fence;
3082   };
3083 
3084   template <>
3085   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
3086   {
3087     using Type = VULKAN_HPP_NAMESPACE::Fence;
3088   };
3089 
3090 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3091   template <>
3092   struct CppType<VkFence, VK_NULL_HANDLE>
3093   {
3094     using Type = VULKAN_HPP_NAMESPACE::Fence;
3095   };
3096 #endif
3097 
3098   template <>
3099   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
3100   {
3101     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3102   };
3103 
3104   class PerformanceConfigurationINTEL
3105   {
3106   public:
3107     using CType      = VkPerformanceConfigurationINTEL;
3108     using NativeType = VkPerformanceConfigurationINTEL;
3109 
3110     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
3111     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3112       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3113 
3114   public:
3115     PerformanceConfigurationINTEL()                                                        = default;
3116     PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & rhs )             = default;
3117     PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & rhs ) = default;
3118     PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs )                  = default;
3119     PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs )      = default;
3120 
PerformanceConfigurationINTEL(std::nullptr_t)3121     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3122 
PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)3123     VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
3124       : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
3125     {
3126     }
3127 
3128 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)3129     PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
3130     {
3131       m_performanceConfigurationINTEL = performanceConfigurationINTEL;
3132       return *this;
3133     }
3134 #endif
3135 
operator =(std::nullptr_t)3136     PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3137     {
3138       m_performanceConfigurationINTEL = {};
3139       return *this;
3140     }
3141 
3142 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3143     auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
3144 #else
operator ==(PerformanceConfigurationINTEL const & rhs) const3145     bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3146     {
3147       return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
3148     }
3149 
operator !=(PerformanceConfigurationINTEL const & rhs) const3150     bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3151     {
3152       return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
3153     }
3154 
operator <(PerformanceConfigurationINTEL const & rhs) const3155     bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3156     {
3157       return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
3158     }
3159 #endif
3160 
operator VkPerformanceConfigurationINTEL() const3161     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
3162     {
3163       return m_performanceConfigurationINTEL;
3164     }
3165 
operator bool() const3166     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3167     {
3168       return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
3169     }
3170 
operator !() const3171     bool operator!() const VULKAN_HPP_NOEXCEPT
3172     {
3173       return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
3174     }
3175 
3176   private:
3177     VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
3178   };
3179 
3180   template <>
3181   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
3182   {
3183     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
3184   };
3185 
3186 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3187   template <>
3188   struct CppType<VkPerformanceConfigurationINTEL, VK_NULL_HANDLE>
3189   {
3190     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
3191   };
3192 #endif
3193 
3194   template <>
3195   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
3196   {
3197     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3198   };
3199 
3200   class QueryPool
3201   {
3202   public:
3203     using CType      = VkQueryPool;
3204     using NativeType = VkQueryPool;
3205 
3206     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
3207     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3208       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
3209 
3210   public:
3211     QueryPool()                                    = default;
3212     QueryPool( QueryPool const & rhs )             = default;
3213     QueryPool & operator=( QueryPool const & rhs ) = default;
3214     QueryPool( QueryPool && rhs )                  = default;
3215     QueryPool & operator=( QueryPool && rhs )      = default;
3216 
QueryPool(std::nullptr_t)3217     VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3218 
QueryPool(VkQueryPool queryPool)3219     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
3220 
3221 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkQueryPool queryPool)3222     QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
3223     {
3224       m_queryPool = queryPool;
3225       return *this;
3226     }
3227 #endif
3228 
operator =(std::nullptr_t)3229     QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3230     {
3231       m_queryPool = {};
3232       return *this;
3233     }
3234 
3235 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3236     auto operator<=>( QueryPool const & ) const = default;
3237 #else
operator ==(QueryPool const & rhs) const3238     bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3239     {
3240       return m_queryPool == rhs.m_queryPool;
3241     }
3242 
operator !=(QueryPool const & rhs) const3243     bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3244     {
3245       return m_queryPool != rhs.m_queryPool;
3246     }
3247 
operator <(QueryPool const & rhs) const3248     bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3249     {
3250       return m_queryPool < rhs.m_queryPool;
3251     }
3252 #endif
3253 
operator VkQueryPool() const3254     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
3255     {
3256       return m_queryPool;
3257     }
3258 
operator bool() const3259     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3260     {
3261       return m_queryPool != VK_NULL_HANDLE;
3262     }
3263 
operator !() const3264     bool operator!() const VULKAN_HPP_NOEXCEPT
3265     {
3266       return m_queryPool == VK_NULL_HANDLE;
3267     }
3268 
3269   private:
3270     VkQueryPool m_queryPool = {};
3271   };
3272 
3273   template <>
3274   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
3275   {
3276     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3277   };
3278 
3279   template <>
3280   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
3281   {
3282     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3283   };
3284 
3285 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3286   template <>
3287   struct CppType<VkQueryPool, VK_NULL_HANDLE>
3288   {
3289     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3290   };
3291 #endif
3292 
3293   template <>
3294   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
3295   {
3296     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3297   };
3298 
3299   class Buffer
3300   {
3301   public:
3302     using CType      = VkBuffer;
3303     using NativeType = VkBuffer;
3304 
3305     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
3306     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3307       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
3308 
3309   public:
3310     Buffer()                                 = default;
3311     Buffer( Buffer const & rhs )             = default;
3312     Buffer & operator=( Buffer const & rhs ) = default;
3313     Buffer( Buffer && rhs )                  = default;
3314     Buffer & operator=( Buffer && rhs )      = default;
3315 
Buffer(std::nullptr_t)3316     VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3317 
Buffer(VkBuffer buffer)3318     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
3319 
3320 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkBuffer buffer)3321     Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
3322     {
3323       m_buffer = buffer;
3324       return *this;
3325     }
3326 #endif
3327 
operator =(std::nullptr_t)3328     Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3329     {
3330       m_buffer = {};
3331       return *this;
3332     }
3333 
3334 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3335     auto operator<=>( Buffer const & ) const = default;
3336 #else
operator ==(Buffer const & rhs) const3337     bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3338     {
3339       return m_buffer == rhs.m_buffer;
3340     }
3341 
operator !=(Buffer const & rhs) const3342     bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3343     {
3344       return m_buffer != rhs.m_buffer;
3345     }
3346 
operator <(Buffer const & rhs) const3347     bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3348     {
3349       return m_buffer < rhs.m_buffer;
3350     }
3351 #endif
3352 
operator VkBuffer() const3353     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
3354     {
3355       return m_buffer;
3356     }
3357 
operator bool() const3358     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3359     {
3360       return m_buffer != VK_NULL_HANDLE;
3361     }
3362 
operator !() const3363     bool operator!() const VULKAN_HPP_NOEXCEPT
3364     {
3365       return m_buffer == VK_NULL_HANDLE;
3366     }
3367 
3368   private:
3369     VkBuffer m_buffer = {};
3370   };
3371 
3372   template <>
3373   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
3374   {
3375     using Type = VULKAN_HPP_NAMESPACE::Buffer;
3376   };
3377 
3378   template <>
3379   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
3380   {
3381     using Type = VULKAN_HPP_NAMESPACE::Buffer;
3382   };
3383 
3384 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3385   template <>
3386   struct CppType<VkBuffer, VK_NULL_HANDLE>
3387   {
3388     using Type = VULKAN_HPP_NAMESPACE::Buffer;
3389   };
3390 #endif
3391 
3392   template <>
3393   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
3394   {
3395     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3396   };
3397 
3398   class PipelineLayout
3399   {
3400   public:
3401     using CType      = VkPipelineLayout;
3402     using NativeType = VkPipelineLayout;
3403 
3404     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
3405     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3406       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
3407 
3408   public:
3409     PipelineLayout()                                         = default;
3410     PipelineLayout( PipelineLayout const & rhs )             = default;
3411     PipelineLayout & operator=( PipelineLayout const & rhs ) = default;
3412     PipelineLayout( PipelineLayout && rhs )                  = default;
3413     PipelineLayout & operator=( PipelineLayout && rhs )      = default;
3414 
PipelineLayout(std::nullptr_t)3415     VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3416 
PipelineLayout(VkPipelineLayout pipelineLayout)3417     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}
3418 
3419 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPipelineLayout pipelineLayout)3420     PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
3421     {
3422       m_pipelineLayout = pipelineLayout;
3423       return *this;
3424     }
3425 #endif
3426 
operator =(std::nullptr_t)3427     PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3428     {
3429       m_pipelineLayout = {};
3430       return *this;
3431     }
3432 
3433 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3434     auto operator<=>( PipelineLayout const & ) const = default;
3435 #else
operator ==(PipelineLayout const & rhs) const3436     bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3437     {
3438       return m_pipelineLayout == rhs.m_pipelineLayout;
3439     }
3440 
operator !=(PipelineLayout const & rhs) const3441     bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3442     {
3443       return m_pipelineLayout != rhs.m_pipelineLayout;
3444     }
3445 
operator <(PipelineLayout const & rhs) const3446     bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3447     {
3448       return m_pipelineLayout < rhs.m_pipelineLayout;
3449     }
3450 #endif
3451 
operator VkPipelineLayout() const3452     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
3453     {
3454       return m_pipelineLayout;
3455     }
3456 
operator bool() const3457     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3458     {
3459       return m_pipelineLayout != VK_NULL_HANDLE;
3460     }
3461 
operator !() const3462     bool operator!() const VULKAN_HPP_NOEXCEPT
3463     {
3464       return m_pipelineLayout == VK_NULL_HANDLE;
3465     }
3466 
3467   private:
3468     VkPipelineLayout m_pipelineLayout = {};
3469   };
3470 
3471   template <>
3472   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
3473   {
3474     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3475   };
3476 
3477   template <>
3478   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
3479   {
3480     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3481   };
3482 
3483 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3484   template <>
3485   struct CppType<VkPipelineLayout, VK_NULL_HANDLE>
3486   {
3487     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3488   };
3489 #endif
3490 
3491   template <>
3492   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
3493   {
3494     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3495   };
3496 
3497   class DescriptorSet
3498   {
3499   public:
3500     using CType      = VkDescriptorSet;
3501     using NativeType = VkDescriptorSet;
3502 
3503     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
3504     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3505       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
3506 
3507   public:
3508     DescriptorSet()                                        = default;
3509     DescriptorSet( DescriptorSet const & rhs )             = default;
3510     DescriptorSet & operator=( DescriptorSet const & rhs ) = default;
3511     DescriptorSet( DescriptorSet && rhs )                  = default;
3512     DescriptorSet & operator=( DescriptorSet && rhs )      = default;
3513 
DescriptorSet(std::nullptr_t)3514     VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3515 
DescriptorSet(VkDescriptorSet descriptorSet)3516     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}
3517 
3518 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDescriptorSet descriptorSet)3519     DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
3520     {
3521       m_descriptorSet = descriptorSet;
3522       return *this;
3523     }
3524 #endif
3525 
operator =(std::nullptr_t)3526     DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3527     {
3528       m_descriptorSet = {};
3529       return *this;
3530     }
3531 
3532 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3533     auto operator<=>( DescriptorSet const & ) const = default;
3534 #else
operator ==(DescriptorSet const & rhs) const3535     bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3536     {
3537       return m_descriptorSet == rhs.m_descriptorSet;
3538     }
3539 
operator !=(DescriptorSet const & rhs) const3540     bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3541     {
3542       return m_descriptorSet != rhs.m_descriptorSet;
3543     }
3544 
operator <(DescriptorSet const & rhs) const3545     bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3546     {
3547       return m_descriptorSet < rhs.m_descriptorSet;
3548     }
3549 #endif
3550 
operator VkDescriptorSet() const3551     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
3552     {
3553       return m_descriptorSet;
3554     }
3555 
operator bool() const3556     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3557     {
3558       return m_descriptorSet != VK_NULL_HANDLE;
3559     }
3560 
operator !() const3561     bool operator!() const VULKAN_HPP_NOEXCEPT
3562     {
3563       return m_descriptorSet == VK_NULL_HANDLE;
3564     }
3565 
3566   private:
3567     VkDescriptorSet m_descriptorSet = {};
3568   };
3569 
3570   template <>
3571   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
3572   {
3573     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3574   };
3575 
3576   template <>
3577   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
3578   {
3579     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3580   };
3581 
3582 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3583   template <>
3584   struct CppType<VkDescriptorSet, VK_NULL_HANDLE>
3585   {
3586     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3587   };
3588 #endif
3589 
3590   template <>
3591   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
3592   {
3593     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3594   };
3595 
3596   class ImageView
3597   {
3598   public:
3599     using CType      = VkImageView;
3600     using NativeType = VkImageView;
3601 
3602     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
3603     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3604       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
3605 
3606   public:
3607     ImageView()                                    = default;
3608     ImageView( ImageView const & rhs )             = default;
3609     ImageView & operator=( ImageView const & rhs ) = default;
3610     ImageView( ImageView && rhs )                  = default;
3611     ImageView & operator=( ImageView && rhs )      = default;
3612 
ImageView(std::nullptr_t)3613     VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3614 
ImageView(VkImageView imageView)3615     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
3616 
3617 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkImageView imageView)3618     ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
3619     {
3620       m_imageView = imageView;
3621       return *this;
3622     }
3623 #endif
3624 
operator =(std::nullptr_t)3625     ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3626     {
3627       m_imageView = {};
3628       return *this;
3629     }
3630 
3631 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3632     auto operator<=>( ImageView const & ) const = default;
3633 #else
operator ==(ImageView const & rhs) const3634     bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3635     {
3636       return m_imageView == rhs.m_imageView;
3637     }
3638 
operator !=(ImageView const & rhs) const3639     bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3640     {
3641       return m_imageView != rhs.m_imageView;
3642     }
3643 
operator <(ImageView const & rhs) const3644     bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3645     {
3646       return m_imageView < rhs.m_imageView;
3647     }
3648 #endif
3649 
operator VkImageView() const3650     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
3651     {
3652       return m_imageView;
3653     }
3654 
operator bool() const3655     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3656     {
3657       return m_imageView != VK_NULL_HANDLE;
3658     }
3659 
operator !() const3660     bool operator!() const VULKAN_HPP_NOEXCEPT
3661     {
3662       return m_imageView == VK_NULL_HANDLE;
3663     }
3664 
3665   private:
3666     VkImageView m_imageView = {};
3667   };
3668 
3669   template <>
3670   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
3671   {
3672     using Type = VULKAN_HPP_NAMESPACE::ImageView;
3673   };
3674 
3675   template <>
3676   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
3677   {
3678     using Type = VULKAN_HPP_NAMESPACE::ImageView;
3679   };
3680 
3681 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3682   template <>
3683   struct CppType<VkImageView, VK_NULL_HANDLE>
3684   {
3685     using Type = VULKAN_HPP_NAMESPACE::ImageView;
3686   };
3687 #endif
3688 
3689   template <>
3690   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
3691   {
3692     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3693   };
3694 
3695   class Pipeline
3696   {
3697   public:
3698     using CType      = VkPipeline;
3699     using NativeType = VkPipeline;
3700 
3701     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
3702     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3703       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
3704 
3705   public:
3706     Pipeline()                                   = default;
3707     Pipeline( Pipeline const & rhs )             = default;
3708     Pipeline & operator=( Pipeline const & rhs ) = default;
3709     Pipeline( Pipeline && rhs )                  = default;
3710     Pipeline & operator=( Pipeline && rhs )      = default;
3711 
Pipeline(std::nullptr_t)3712     VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3713 
Pipeline(VkPipeline pipeline)3714     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
3715 
3716 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPipeline pipeline)3717     Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
3718     {
3719       m_pipeline = pipeline;
3720       return *this;
3721     }
3722 #endif
3723 
operator =(std::nullptr_t)3724     Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3725     {
3726       m_pipeline = {};
3727       return *this;
3728     }
3729 
3730 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3731     auto operator<=>( Pipeline const & ) const = default;
3732 #else
operator ==(Pipeline const & rhs) const3733     bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3734     {
3735       return m_pipeline == rhs.m_pipeline;
3736     }
3737 
operator !=(Pipeline const & rhs) const3738     bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3739     {
3740       return m_pipeline != rhs.m_pipeline;
3741     }
3742 
operator <(Pipeline const & rhs) const3743     bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3744     {
3745       return m_pipeline < rhs.m_pipeline;
3746     }
3747 #endif
3748 
operator VkPipeline() const3749     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
3750     {
3751       return m_pipeline;
3752     }
3753 
operator bool() const3754     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3755     {
3756       return m_pipeline != VK_NULL_HANDLE;
3757     }
3758 
operator !() const3759     bool operator!() const VULKAN_HPP_NOEXCEPT
3760     {
3761       return m_pipeline == VK_NULL_HANDLE;
3762     }
3763 
3764   private:
3765     VkPipeline m_pipeline = {};
3766   };
3767 
3768   template <>
3769   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
3770   {
3771     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
3772   };
3773 
3774   template <>
3775   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
3776   {
3777     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
3778   };
3779 
3780 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3781   template <>
3782   struct CppType<VkPipeline, VK_NULL_HANDLE>
3783   {
3784     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
3785   };
3786 #endif
3787 
3788   template <>
3789   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
3790   {
3791     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3792   };
3793 
3794   class ShaderEXT
3795   {
3796   public:
3797     using CType      = VkShaderEXT;
3798     using NativeType = VkShaderEXT;
3799 
3800     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT;
3801     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3802       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3803 
3804   public:
3805     ShaderEXT()                                    = default;
3806     ShaderEXT( ShaderEXT const & rhs )             = default;
3807     ShaderEXT & operator=( ShaderEXT const & rhs ) = default;
3808     ShaderEXT( ShaderEXT && rhs )                  = default;
3809     ShaderEXT & operator=( ShaderEXT && rhs )      = default;
3810 
ShaderEXT(std::nullptr_t)3811     VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3812 
ShaderEXT(VkShaderEXT shaderEXT)3813     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {}
3814 
3815 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkShaderEXT shaderEXT)3816     ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT
3817     {
3818       m_shaderEXT = shaderEXT;
3819       return *this;
3820     }
3821 #endif
3822 
operator =(std::nullptr_t)3823     ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3824     {
3825       m_shaderEXT = {};
3826       return *this;
3827     }
3828 
3829 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3830     auto operator<=>( ShaderEXT const & ) const = default;
3831 #else
operator ==(ShaderEXT const & rhs) const3832     bool operator==( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3833     {
3834       return m_shaderEXT == rhs.m_shaderEXT;
3835     }
3836 
operator !=(ShaderEXT const & rhs) const3837     bool operator!=( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3838     {
3839       return m_shaderEXT != rhs.m_shaderEXT;
3840     }
3841 
operator <(ShaderEXT const & rhs) const3842     bool operator<( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3843     {
3844       return m_shaderEXT < rhs.m_shaderEXT;
3845     }
3846 #endif
3847 
operator VkShaderEXT() const3848     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT
3849     {
3850       return m_shaderEXT;
3851     }
3852 
operator bool() const3853     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3854     {
3855       return m_shaderEXT != VK_NULL_HANDLE;
3856     }
3857 
operator !() const3858     bool operator!() const VULKAN_HPP_NOEXCEPT
3859     {
3860       return m_shaderEXT == VK_NULL_HANDLE;
3861     }
3862 
3863   private:
3864     VkShaderEXT m_shaderEXT = {};
3865   };
3866 
3867   template <>
3868   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT>
3869   {
3870     using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;
3871   };
3872 
3873 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3874   template <>
3875   struct CppType<VkShaderEXT, VK_NULL_HANDLE>
3876   {
3877     using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;
3878   };
3879 #endif
3880 
3881   template <>
3882   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderEXT>
3883   {
3884     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3885   };
3886 
3887   class Image
3888   {
3889   public:
3890     using CType      = VkImage;
3891     using NativeType = VkImage;
3892 
3893     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;
3894     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3895       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
3896 
3897   public:
3898     Image()                                = default;
3899     Image( Image const & rhs )             = default;
3900     Image & operator=( Image const & rhs ) = default;
3901     Image( Image && rhs )                  = default;
3902     Image & operator=( Image && rhs )      = default;
3903 
Image(std::nullptr_t)3904     VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3905 
Image(VkImage image)3906     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
3907 
3908 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkImage image)3909     Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
3910     {
3911       m_image = image;
3912       return *this;
3913     }
3914 #endif
3915 
operator =(std::nullptr_t)3916     Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3917     {
3918       m_image = {};
3919       return *this;
3920     }
3921 
3922 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3923     auto operator<=>( Image const & ) const = default;
3924 #else
operator ==(Image const & rhs) const3925     bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3926     {
3927       return m_image == rhs.m_image;
3928     }
3929 
operator !=(Image const & rhs) const3930     bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3931     {
3932       return m_image != rhs.m_image;
3933     }
3934 
operator <(Image const & rhs) const3935     bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3936     {
3937       return m_image < rhs.m_image;
3938     }
3939 #endif
3940 
operator VkImage() const3941     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
3942     {
3943       return m_image;
3944     }
3945 
operator bool() const3946     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3947     {
3948       return m_image != VK_NULL_HANDLE;
3949     }
3950 
operator !() const3951     bool operator!() const VULKAN_HPP_NOEXCEPT
3952     {
3953       return m_image == VK_NULL_HANDLE;
3954     }
3955 
3956   private:
3957     VkImage m_image = {};
3958   };
3959 
3960   template <>
3961   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
3962   {
3963     using Type = VULKAN_HPP_NAMESPACE::Image;
3964   };
3965 
3966   template <>
3967   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
3968   {
3969     using Type = VULKAN_HPP_NAMESPACE::Image;
3970   };
3971 
3972 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3973   template <>
3974   struct CppType<VkImage, VK_NULL_HANDLE>
3975   {
3976     using Type = VULKAN_HPP_NAMESPACE::Image;
3977   };
3978 #endif
3979 
3980   template <>
3981   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
3982   {
3983     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3984   };
3985 
3986   class AccelerationStructureNV
3987   {
3988   public:
3989     using CType      = VkAccelerationStructureNV;
3990     using NativeType = VkAccelerationStructureNV;
3991 
3992     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
3993     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3994       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
3995 
3996   public:
3997     AccelerationStructureNV()                                                  = default;
3998     AccelerationStructureNV( AccelerationStructureNV const & rhs )             = default;
3999     AccelerationStructureNV & operator=( AccelerationStructureNV const & rhs ) = default;
4000     AccelerationStructureNV( AccelerationStructureNV && rhs )                  = default;
4001     AccelerationStructureNV & operator=( AccelerationStructureNV && rhs )      = default;
4002 
AccelerationStructureNV(std::nullptr_t)4003     VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4004 
AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV)4005     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
4006       : m_accelerationStructureNV( accelerationStructureNV )
4007     {
4008     }
4009 
4010 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkAccelerationStructureNV accelerationStructureNV)4011     AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
4012     {
4013       m_accelerationStructureNV = accelerationStructureNV;
4014       return *this;
4015     }
4016 #endif
4017 
operator =(std::nullptr_t)4018     AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4019     {
4020       m_accelerationStructureNV = {};
4021       return *this;
4022     }
4023 
4024 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4025     auto operator<=>( AccelerationStructureNV const & ) const = default;
4026 #else
operator ==(AccelerationStructureNV const & rhs) const4027     bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4028     {
4029       return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
4030     }
4031 
operator !=(AccelerationStructureNV const & rhs) const4032     bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4033     {
4034       return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
4035     }
4036 
operator <(AccelerationStructureNV const & rhs) const4037     bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4038     {
4039       return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
4040     }
4041 #endif
4042 
operator VkAccelerationStructureNV() const4043     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
4044     {
4045       return m_accelerationStructureNV;
4046     }
4047 
operator bool() const4048     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4049     {
4050       return m_accelerationStructureNV != VK_NULL_HANDLE;
4051     }
4052 
operator !() const4053     bool operator!() const VULKAN_HPP_NOEXCEPT
4054     {
4055       return m_accelerationStructureNV == VK_NULL_HANDLE;
4056     }
4057 
4058   private:
4059     VkAccelerationStructureNV m_accelerationStructureNV = {};
4060   };
4061 
4062   template <>
4063   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
4064   {
4065     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
4066   };
4067 
4068   template <>
4069   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
4070   {
4071     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
4072   };
4073 
4074 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4075   template <>
4076   struct CppType<VkAccelerationStructureNV, VK_NULL_HANDLE>
4077   {
4078     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
4079   };
4080 #endif
4081 
4082   template <>
4083   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
4084   {
4085     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4086   };
4087 
4088   class OpticalFlowSessionNV
4089   {
4090   public:
4091     using CType      = VkOpticalFlowSessionNV;
4092     using NativeType = VkOpticalFlowSessionNV;
4093 
4094     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;
4095     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4096       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4097 
4098   public:
4099     OpticalFlowSessionNV()                                               = default;
4100     OpticalFlowSessionNV( OpticalFlowSessionNV const & rhs )             = default;
4101     OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & rhs ) = default;
4102     OpticalFlowSessionNV( OpticalFlowSessionNV && rhs )                  = default;
4103     OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs )      = default;
4104 
OpticalFlowSessionNV(std::nullptr_t)4105     VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4106 
OpticalFlowSessionNV(VkOpticalFlowSessionNV opticalFlowSessionNV)4107     VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
4108       : m_opticalFlowSessionNV( opticalFlowSessionNV )
4109     {
4110     }
4111 
4112 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkOpticalFlowSessionNV opticalFlowSessionNV)4113     OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
4114     {
4115       m_opticalFlowSessionNV = opticalFlowSessionNV;
4116       return *this;
4117     }
4118 #endif
4119 
operator =(std::nullptr_t)4120     OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4121     {
4122       m_opticalFlowSessionNV = {};
4123       return *this;
4124     }
4125 
4126 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4127     auto operator<=>( OpticalFlowSessionNV const & ) const = default;
4128 #else
operator ==(OpticalFlowSessionNV const & rhs) const4129     bool operator==( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4130     {
4131       return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;
4132     }
4133 
operator !=(OpticalFlowSessionNV const & rhs) const4134     bool operator!=( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4135     {
4136       return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;
4137     }
4138 
operator <(OpticalFlowSessionNV const & rhs) const4139     bool operator<( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4140     {
4141       return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;
4142     }
4143 #endif
4144 
operator VkOpticalFlowSessionNV() const4145     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
4146     {
4147       return m_opticalFlowSessionNV;
4148     }
4149 
operator bool() const4150     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4151     {
4152       return m_opticalFlowSessionNV != VK_NULL_HANDLE;
4153     }
4154 
operator !() const4155     bool operator!() const VULKAN_HPP_NOEXCEPT
4156     {
4157       return m_opticalFlowSessionNV == VK_NULL_HANDLE;
4158     }
4159 
4160   private:
4161     VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};
4162   };
4163 
4164   template <>
4165   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV>
4166   {
4167     using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
4168   };
4169 
4170 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4171   template <>
4172   struct CppType<VkOpticalFlowSessionNV, VK_NULL_HANDLE>
4173   {
4174     using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
4175   };
4176 #endif
4177 
4178   template <>
4179   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>
4180   {
4181     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4182   };
4183 
4184   class DescriptorUpdateTemplate
4185   {
4186   public:
4187     using CType      = VkDescriptorUpdateTemplate;
4188     using NativeType = VkDescriptorUpdateTemplate;
4189 
4190     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
4191     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4192       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
4193 
4194   public:
4195     DescriptorUpdateTemplate()                                                   = default;
4196     DescriptorUpdateTemplate( DescriptorUpdateTemplate const & rhs )             = default;
4197     DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & rhs ) = default;
4198     DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs )                  = default;
4199     DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs )      = default;
4200 
DescriptorUpdateTemplate(std::nullptr_t)4201     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4202 
DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate)4203     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
4204       : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
4205     {
4206     }
4207 
4208 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDescriptorUpdateTemplate descriptorUpdateTemplate)4209     DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
4210     {
4211       m_descriptorUpdateTemplate = descriptorUpdateTemplate;
4212       return *this;
4213     }
4214 #endif
4215 
operator =(std::nullptr_t)4216     DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4217     {
4218       m_descriptorUpdateTemplate = {};
4219       return *this;
4220     }
4221 
4222 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4223     auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
4224 #else
operator ==(DescriptorUpdateTemplate const & rhs) const4225     bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
4226     {
4227       return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
4228     }
4229 
operator !=(DescriptorUpdateTemplate const & rhs) const4230     bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
4231     {
4232       return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
4233     }
4234 
operator <(DescriptorUpdateTemplate const & rhs) const4235     bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
4236     {
4237       return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
4238     }
4239 #endif
4240 
operator VkDescriptorUpdateTemplate() const4241     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
4242     {
4243       return m_descriptorUpdateTemplate;
4244     }
4245 
operator bool() const4246     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4247     {
4248       return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
4249     }
4250 
operator !() const4251     bool operator!() const VULKAN_HPP_NOEXCEPT
4252     {
4253       return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
4254     }
4255 
4256   private:
4257     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
4258   };
4259 
4260   template <>
4261   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
4262   {
4263     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
4264   };
4265 
4266   template <>
4267   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
4268   {
4269     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
4270   };
4271 
4272 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4273   template <>
4274   struct CppType<VkDescriptorUpdateTemplate, VK_NULL_HANDLE>
4275   {
4276     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
4277   };
4278 #endif
4279 
4280   template <>
4281   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
4282   {
4283     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4284   };
4285 
4286   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
4287 
4288   class Event
4289   {
4290   public:
4291     using CType      = VkEvent;
4292     using NativeType = VkEvent;
4293 
4294     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
4295     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4296       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
4297 
4298   public:
4299     Event()                                = default;
4300     Event( Event const & rhs )             = default;
4301     Event & operator=( Event const & rhs ) = default;
4302     Event( Event && rhs )                  = default;
4303     Event & operator=( Event && rhs )      = default;
4304 
Event(std::nullptr_t)4305     VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4306 
Event(VkEvent event)4307     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
4308 
4309 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkEvent event)4310     Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
4311     {
4312       m_event = event;
4313       return *this;
4314     }
4315 #endif
4316 
operator =(std::nullptr_t)4317     Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4318     {
4319       m_event = {};
4320       return *this;
4321     }
4322 
4323 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4324     auto operator<=>( Event const & ) const = default;
4325 #else
operator ==(Event const & rhs) const4326     bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4327     {
4328       return m_event == rhs.m_event;
4329     }
4330 
operator !=(Event const & rhs) const4331     bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4332     {
4333       return m_event != rhs.m_event;
4334     }
4335 
operator <(Event const & rhs) const4336     bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4337     {
4338       return m_event < rhs.m_event;
4339     }
4340 #endif
4341 
operator VkEvent() const4342     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
4343     {
4344       return m_event;
4345     }
4346 
operator bool() const4347     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4348     {
4349       return m_event != VK_NULL_HANDLE;
4350     }
4351 
operator !() const4352     bool operator!() const VULKAN_HPP_NOEXCEPT
4353     {
4354       return m_event == VK_NULL_HANDLE;
4355     }
4356 
4357   private:
4358     VkEvent m_event = {};
4359   };
4360 
4361   template <>
4362   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
4363   {
4364     using Type = VULKAN_HPP_NAMESPACE::Event;
4365   };
4366 
4367   template <>
4368   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
4369   {
4370     using Type = VULKAN_HPP_NAMESPACE::Event;
4371   };
4372 
4373 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4374   template <>
4375   struct CppType<VkEvent, VK_NULL_HANDLE>
4376   {
4377     using Type = VULKAN_HPP_NAMESPACE::Event;
4378   };
4379 #endif
4380 
4381   template <>
4382   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
4383   {
4384     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4385   };
4386 
4387   class AccelerationStructureKHR
4388   {
4389   public:
4390     using CType      = VkAccelerationStructureKHR;
4391     using NativeType = VkAccelerationStructureKHR;
4392 
4393     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
4394     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4395       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
4396 
4397   public:
4398     AccelerationStructureKHR()                                                   = default;
4399     AccelerationStructureKHR( AccelerationStructureKHR const & rhs )             = default;
4400     AccelerationStructureKHR & operator=( AccelerationStructureKHR const & rhs ) = default;
4401     AccelerationStructureKHR( AccelerationStructureKHR && rhs )                  = default;
4402     AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs )      = default;
4403 
AccelerationStructureKHR(std::nullptr_t)4404     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4405 
AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR)4406     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4407       : m_accelerationStructureKHR( accelerationStructureKHR )
4408     {
4409     }
4410 
4411 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkAccelerationStructureKHR accelerationStructureKHR)4412     AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4413     {
4414       m_accelerationStructureKHR = accelerationStructureKHR;
4415       return *this;
4416     }
4417 #endif
4418 
operator =(std::nullptr_t)4419     AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4420     {
4421       m_accelerationStructureKHR = {};
4422       return *this;
4423     }
4424 
4425 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4426     auto operator<=>( AccelerationStructureKHR const & ) const = default;
4427 #else
operator ==(AccelerationStructureKHR const & rhs) const4428     bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4429     {
4430       return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
4431     }
4432 
operator !=(AccelerationStructureKHR const & rhs) const4433     bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4434     {
4435       return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
4436     }
4437 
operator <(AccelerationStructureKHR const & rhs) const4438     bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4439     {
4440       return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
4441     }
4442 #endif
4443 
operator VkAccelerationStructureKHR() const4444     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
4445     {
4446       return m_accelerationStructureKHR;
4447     }
4448 
operator bool() const4449     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4450     {
4451       return m_accelerationStructureKHR != VK_NULL_HANDLE;
4452     }
4453 
operator !() const4454     bool operator!() const VULKAN_HPP_NOEXCEPT
4455     {
4456       return m_accelerationStructureKHR == VK_NULL_HANDLE;
4457     }
4458 
4459   private:
4460     VkAccelerationStructureKHR m_accelerationStructureKHR = {};
4461   };
4462 
4463   template <>
4464   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
4465   {
4466     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4467   };
4468 
4469   template <>
4470   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
4471   {
4472     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4473   };
4474 
4475 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4476   template <>
4477   struct CppType<VkAccelerationStructureKHR, VK_NULL_HANDLE>
4478   {
4479     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4480   };
4481 #endif
4482 
4483   template <>
4484   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
4485   {
4486     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4487   };
4488 
4489   class MicromapEXT
4490   {
4491   public:
4492     using CType      = VkMicromapEXT;
4493     using NativeType = VkMicromapEXT;
4494 
4495     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;
4496     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4497       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4498 
4499   public:
4500     MicromapEXT()                                      = default;
4501     MicromapEXT( MicromapEXT const & rhs )             = default;
4502     MicromapEXT & operator=( MicromapEXT const & rhs ) = default;
4503     MicromapEXT( MicromapEXT && rhs )                  = default;
4504     MicromapEXT & operator=( MicromapEXT && rhs )      = default;
4505 
MicromapEXT(std::nullptr_t)4506     VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4507 
MicromapEXT(VkMicromapEXT micromapEXT)4508     VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}
4509 
4510 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkMicromapEXT micromapEXT)4511     MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
4512     {
4513       m_micromapEXT = micromapEXT;
4514       return *this;
4515     }
4516 #endif
4517 
operator =(std::nullptr_t)4518     MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4519     {
4520       m_micromapEXT = {};
4521       return *this;
4522     }
4523 
4524 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4525     auto operator<=>( MicromapEXT const & ) const = default;
4526 #else
operator ==(MicromapEXT const & rhs) const4527     bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4528     {
4529       return m_micromapEXT == rhs.m_micromapEXT;
4530     }
4531 
operator !=(MicromapEXT const & rhs) const4532     bool operator!=( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4533     {
4534       return m_micromapEXT != rhs.m_micromapEXT;
4535     }
4536 
operator <(MicromapEXT const & rhs) const4537     bool operator<( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4538     {
4539       return m_micromapEXT < rhs.m_micromapEXT;
4540     }
4541 #endif
4542 
operator VkMicromapEXT() const4543     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT
4544     {
4545       return m_micromapEXT;
4546     }
4547 
operator bool() const4548     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4549     {
4550       return m_micromapEXT != VK_NULL_HANDLE;
4551     }
4552 
operator !() const4553     bool operator!() const VULKAN_HPP_NOEXCEPT
4554     {
4555       return m_micromapEXT == VK_NULL_HANDLE;
4556     }
4557 
4558   private:
4559     VkMicromapEXT m_micromapEXT = {};
4560   };
4561 
4562   template <>
4563   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT>
4564   {
4565     using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;
4566   };
4567 
4568 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4569   template <>
4570   struct CppType<VkMicromapEXT, VK_NULL_HANDLE>
4571   {
4572     using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;
4573   };
4574 #endif
4575 
4576   template <>
4577   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::MicromapEXT>
4578   {
4579     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4580   };
4581 
4582   class CommandBuffer
4583   {
4584   public:
4585     using CType      = VkCommandBuffer;
4586     using NativeType = VkCommandBuffer;
4587 
4588     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
4589     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4590       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
4591 
4592   public:
4593     CommandBuffer()                                        = default;
4594     CommandBuffer( CommandBuffer const & rhs )             = default;
4595     CommandBuffer & operator=( CommandBuffer const & rhs ) = default;
4596     CommandBuffer( CommandBuffer && rhs )                  = default;
4597     CommandBuffer & operator=( CommandBuffer && rhs )      = default;
4598 
CommandBuffer(std::nullptr_t)4599     VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4600 
CommandBuffer(VkCommandBuffer commandBuffer)4601     CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}
4602 
operator =(VkCommandBuffer commandBuffer)4603     CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
4604     {
4605       m_commandBuffer = commandBuffer;
4606       return *this;
4607     }
4608 
operator =(std::nullptr_t)4609     CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4610     {
4611       m_commandBuffer = {};
4612       return *this;
4613     }
4614 
4615 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4616     auto operator<=>( CommandBuffer const & ) const = default;
4617 #else
operator ==(CommandBuffer const & rhs) const4618     bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4619     {
4620       return m_commandBuffer == rhs.m_commandBuffer;
4621     }
4622 
operator !=(CommandBuffer const & rhs) const4623     bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4624     {
4625       return m_commandBuffer != rhs.m_commandBuffer;
4626     }
4627 
operator <(CommandBuffer const & rhs) const4628     bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4629     {
4630       return m_commandBuffer < rhs.m_commandBuffer;
4631     }
4632 #endif
4633 
4634     //=== VK_VERSION_1_0 ===
4635 
4636     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4637     VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,
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     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo,
4642                                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4643 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4644 
4645 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4646     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4647     VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4648 #else
4649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4650     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4651 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4652 
4653 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4654     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4655     VULKAN_HPP_NODISCARD Result reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,
4656                                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4657 #else
4658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4659     typename ResultValueType<void>::type reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
4660                                                 Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4661 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4662 
4663     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4664     void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
4665                        VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
4666                        Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4667 
4668     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4669     void setViewport( uint32_t                               firstViewport,
4670                       uint32_t                               viewportCount,
4671                       const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4672                       Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4673 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4674     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4675     void setViewport( uint32_t                                                                       firstViewport,
4676                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
4677                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4678 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4679 
4680     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4681     void setScissor( uint32_t                             firstScissor,
4682                      uint32_t                             scissorCount,
4683                      const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4684                      Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4685 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4686     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4687     void setScissor( uint32_t                                                                     firstScissor,
4688                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
4689                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4690 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4691 
4692     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4693     void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4694 
4695     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4696     void setDepthBias( float              depthBiasConstantFactor,
4697                        float              depthBiasClamp,
4698                        float              depthBiasSlopeFactor,
4699                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4700 
4701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4702     void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4703 
4704     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4705     void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4706 
4707     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4708     void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
4709                                 uint32_t                               compareMask,
4710                                 Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4711 
4712     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4713     void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
4714                               uint32_t                               writeMask,
4715                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4716 
4717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4718     void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
4719                               uint32_t                               reference,
4720                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4721 
4722     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4723     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint     pipelineBindPoint,
4724                              VULKAN_HPP_NAMESPACE::PipelineLayout        layout,
4725                              uint32_t                                    firstSet,
4726                              uint32_t                                    descriptorSetCount,
4727                              const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
4728                              uint32_t                                    dynamicOffsetCount,
4729                              const uint32_t *                            pDynamicOffsets,
4730                              Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4731 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4733     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                             pipelineBindPoint,
4734                              VULKAN_HPP_NAMESPACE::PipelineLayout                                                layout,
4735                              uint32_t                                                                            firstSet,
4736                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
4737                              VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                            dynamicOffsets,
4738                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4739 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4740 
4741     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4742     void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4743                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
4744                           VULKAN_HPP_NAMESPACE::IndexType  indexType,
4745                           Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4746 
4747     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4748     void bindVertexBuffers( uint32_t                                 firstBinding,
4749                             uint32_t                                 bindingCount,
4750                             const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
4751                             const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4752                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4753 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4754     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4755     void bindVertexBuffers( uint32_t                                                                         firstBinding,
4756                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
4757                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
4758                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4759 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4760 
4761     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4762     void draw( uint32_t           vertexCount,
4763                uint32_t           instanceCount,
4764                uint32_t           firstVertex,
4765                uint32_t           firstInstance,
4766                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4767 
4768     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4769     void drawIndexed( uint32_t           indexCount,
4770                       uint32_t           instanceCount,
4771                       uint32_t           firstIndex,
4772                       int32_t            vertexOffset,
4773                       uint32_t           firstInstance,
4774                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4775 
4776     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4777     void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4778                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
4779                        uint32_t                         drawCount,
4780                        uint32_t                         stride,
4781                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4782 
4783     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4784     void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4785                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
4786                               uint32_t                         drawCount,
4787                               uint32_t                         stride,
4788                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4789 
4790     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4791     void dispatch( uint32_t           groupCountX,
4792                    uint32_t           groupCountY,
4793                    uint32_t           groupCountZ,
4794                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4795 
4796     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4797     void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4798                            VULKAN_HPP_NAMESPACE::DeviceSize offset,
4799                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4800 
4801     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4802     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
4803                      VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
4804                      uint32_t                                 regionCount,
4805                      const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
4806                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4807 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4808     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4809     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                                                     srcBuffer,
4810                      VULKAN_HPP_NAMESPACE::Buffer                                                     dstBuffer,
4811                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
4812                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4813 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4814 
4815     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4816     void copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
4817                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
4818                     VULKAN_HPP_NAMESPACE::Image             dstImage,
4819                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
4820                     uint32_t                                regionCount,
4821                     const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
4822                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4823 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4825     void copyImage( VULKAN_HPP_NAMESPACE::Image                                                     srcImage,
4826                     VULKAN_HPP_NAMESPACE::ImageLayout                                               srcImageLayout,
4827                     VULKAN_HPP_NAMESPACE::Image                                                     dstImage,
4828                     VULKAN_HPP_NAMESPACE::ImageLayout                                               dstImageLayout,
4829                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
4830                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4831 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4832 
4833     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4834     void blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
4835                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
4836                     VULKAN_HPP_NAMESPACE::Image             dstImage,
4837                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
4838                     uint32_t                                regionCount,
4839                     const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
4840                     VULKAN_HPP_NAMESPACE::Filter            filter,
4841                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4844     void blitImage( VULKAN_HPP_NAMESPACE::Image                                                     srcImage,
4845                     VULKAN_HPP_NAMESPACE::ImageLayout                                               srcImageLayout,
4846                     VULKAN_HPP_NAMESPACE::Image                                                     dstImage,
4847                     VULKAN_HPP_NAMESPACE::ImageLayout                                               dstImageLayout,
4848                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
4849                     VULKAN_HPP_NAMESPACE::Filter                                                    filter,
4850                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4851 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4852 
4853     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4854     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
4855                             VULKAN_HPP_NAMESPACE::Image                   dstImage,
4856                             VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
4857                             uint32_t                                      regionCount,
4858                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
4859                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4860 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4862     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                                          srcBuffer,
4863                             VULKAN_HPP_NAMESPACE::Image                                                           dstImage,
4864                             VULKAN_HPP_NAMESPACE::ImageLayout                                                     dstImageLayout,
4865                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
4866                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4867 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4868 
4869     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4870     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
4871                             VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
4872                             VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
4873                             uint32_t                                      regionCount,
4874                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
4875                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4877     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4878     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                                           srcImage,
4879                             VULKAN_HPP_NAMESPACE::ImageLayout                                                     srcImageLayout,
4880                             VULKAN_HPP_NAMESPACE::Buffer                                                          dstBuffer,
4881                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
4882                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4883 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4884 
4885     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4886     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
4887                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
4888                        VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
4889                        const void *                     pData,
4890                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4891 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4892     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4893     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer                             dstBuffer,
4894                        VULKAN_HPP_NAMESPACE::DeviceSize                         dstOffset,
4895                        VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data,
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 fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
4901                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
4902                      VULKAN_HPP_NAMESPACE::DeviceSize size,
4903                      uint32_t                         data,
4904                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4905 
4906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4907     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                         image,
4908                           VULKAN_HPP_NAMESPACE::ImageLayout                   imageLayout,
4909                           const VULKAN_HPP_NAMESPACE::ClearColorValue *       pColor,
4910                           uint32_t                                            rangeCount,
4911                           const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
4912                           Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4913 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4915     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                                                                 image,
4916                           VULKAN_HPP_NAMESPACE::ImageLayout                                                           imageLayout,
4917                           const VULKAN_HPP_NAMESPACE::ClearColorValue &                                               color,
4918                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
4919                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4920 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4921 
4922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4923     void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                          image,
4924                                  VULKAN_HPP_NAMESPACE::ImageLayout                    imageLayout,
4925                                  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
4926                                  uint32_t                                             rangeCount,
4927                                  const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *  pRanges,
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 clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                                                                 image,
4932                                  VULKAN_HPP_NAMESPACE::ImageLayout                                                           imageLayout,
4933                                  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &                                        depthStencil,
4934                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
4935                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4936 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4937 
4938     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4939     void clearAttachments( uint32_t                                      attachmentCount,
4940                            const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
4941                            uint32_t                                      rectCount,
4942                            const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
4943                            Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4944 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4945     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4946     void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
4947                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
4948                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4949 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4950 
4951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4952     void resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,
4953                        VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,
4954                        VULKAN_HPP_NAMESPACE::Image                dstImage,
4955                        VULKAN_HPP_NAMESPACE::ImageLayout          dstImageLayout,
4956                        uint32_t                                   regionCount,
4957                        const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
4958                        Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4959 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4960     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4961     void resolveImage( VULKAN_HPP_NAMESPACE::Image                                                        srcImage,
4962                        VULKAN_HPP_NAMESPACE::ImageLayout                                                  srcImageLayout,
4963                        VULKAN_HPP_NAMESPACE::Image                                                        dstImage,
4964                        VULKAN_HPP_NAMESPACE::ImageLayout                                                  dstImageLayout,
4965                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
4966                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4967 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4968 
4969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4970     void setEvent( VULKAN_HPP_NAMESPACE::Event              event,
4971                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
4972                    Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4973 
4974     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4975     void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
4976                      VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
4977                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4978 
4979     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4980     void waitEvents( uint32_t                                          eventCount,
4981                      const VULKAN_HPP_NAMESPACE::Event *               pEvents,
4982                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
4983                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
4984                      uint32_t                                          memoryBarrierCount,
4985                      const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
4986                      uint32_t                                          bufferMemoryBarrierCount,
4987                      const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
4988                      uint32_t                                          imageMemoryBarrierCount,
4989                      const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
4990                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4992     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4993     void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
4994                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  srcStageMask,
4995                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  dstStageMask,
4996                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
4997                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
4998                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
4999                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5001 
5002     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5003     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
5004                           VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
5005                           VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
5006                           uint32_t                                          memoryBarrierCount,
5007                           const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
5008                           uint32_t                                          bufferMemoryBarrierCount,
5009                           const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
5010                           uint32_t                                          imageMemoryBarrierCount,
5011                           const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
5012                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5013 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5015     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  srcStageMask,
5016                           VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  dstStageMask,
5017                           VULKAN_HPP_NAMESPACE::DependencyFlags                                                     dependencyFlags,
5018                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
5019                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
5020                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
5021                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5022 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5023 
5024     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5025     void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
5026                      uint32_t                                query,
5027                      VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
5028                      Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5029 
5030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5031     void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5032                    uint32_t                        query,
5033                    Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5034 
5035     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5036     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5037                          uint32_t                        firstQuery,
5038                          uint32_t                        queryCount,
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 writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
5043                          VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
5044                          uint32_t                                    query,
5045                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5046 
5047     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5048     void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
5049                                uint32_t                               firstQuery,
5050                                uint32_t                               queryCount,
5051                                VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
5052                                VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
5053                                VULKAN_HPP_NAMESPACE::DeviceSize       stride,
5054                                VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
5055                                Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5056 
5057     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5058     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
5059                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
5060                         uint32_t                               offset,
5061                         uint32_t                               size,
5062                         const void *                           pValues,
5063                         Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5064 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5065     template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5066     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout                       layout,
5067                         VULKAN_HPP_NAMESPACE::ShaderStageFlags                     stageFlags,
5068                         uint32_t                                                   offset,
5069                         VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values,
5070                         Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5071 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5072 
5073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5074     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
5075                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,
5076                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5077 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5078     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5079     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5080                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,
5081                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5082 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5083 
5084     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5085     void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5086 
5087     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5088     void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5089 
5090     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5091     void executeCommands( uint32_t                                    commandBufferCount,
5092                           const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
5093                           Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5094 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5095     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5096     void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
5097                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5098 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5099 
5100     //=== VK_VERSION_1_1 ===
5101 
5102     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5103     void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5104 
5105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5106     void dispatchBase( uint32_t           baseGroupX,
5107                        uint32_t           baseGroupY,
5108                        uint32_t           baseGroupZ,
5109                        uint32_t           groupCountX,
5110                        uint32_t           groupCountY,
5111                        uint32_t           groupCountZ,
5112                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5113 
5114     //=== VK_VERSION_1_2 ===
5115 
5116     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5117     void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5118                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
5119                             VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5120                             VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5121                             uint32_t                         maxDrawCount,
5122                             uint32_t                         stride,
5123                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5124 
5125     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5126     void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5127                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
5128                                    VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5129                                    VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5130                                    uint32_t                         maxDrawCount,
5131                                    uint32_t                         stride,
5132                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5133 
5134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5135     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
5136                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
5137                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5138 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5139     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5140     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5141                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
5142                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5143 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5144 
5145     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5146     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
5147                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
5148                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5149 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5150     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5151     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5152                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
5153                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5154 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5155 
5156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5157     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
5158                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5159 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5160     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5161     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
5162                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5163 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5164 
5165     //=== VK_VERSION_1_3 ===
5166 
5167     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5168     void setEvent2( VULKAN_HPP_NAMESPACE::Event                  event,
5169                     const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
5170                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5171 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5172     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5173     void setEvent2( VULKAN_HPP_NAMESPACE::Event                  event,
5174                     const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
5175                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5176 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5177 
5178     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5179     void resetEvent2( VULKAN_HPP_NAMESPACE::Event               event,
5180                       VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,
5181                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5182 
5183     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5184     void waitEvents2( uint32_t                                     eventCount,
5185                       const VULKAN_HPP_NAMESPACE::Event *          pEvents,
5186                       const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
5187                       Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5188 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5189     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5190     void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &          events,
5191                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,
5192                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5193 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5194 
5195     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5196     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
5197                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5198 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5199     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5200     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
5201                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5202 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5203 
5204     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5205     void writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
5206                           VULKAN_HPP_NAMESPACE::QueryPool           queryPool,
5207                           uint32_t                                  query,
5208                           Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5209 
5210     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5211     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
5212                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5213 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5214     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5215     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
5216                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5217 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5218 
5219     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5220     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
5221                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5222 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5223     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5224     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
5225                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5226 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5227 
5228     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5229     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
5230                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5231 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5232     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5233     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
5234                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5235 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5236 
5237     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5238     void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
5239                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5240 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5241     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5242     void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
5243                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5245 
5246     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5247     void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
5248                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5249 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5250     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5251     void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
5252                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5253 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5254 
5255     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5256     void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
5257                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5258 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5259     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5260     void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
5261                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5262 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5263 
5264     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5265     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
5266                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5267 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5269     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
5270                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5271 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5272 
5273     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5274     void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5275 
5276     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5277     void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5278 
5279     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5280     void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5281 
5282     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5283     void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
5284                                Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5285 
5286     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5287     void setViewportWithCount( uint32_t                               viewportCount,
5288                                const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
5289                                Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5290 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5291     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5292     void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
5293                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5294 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5295 
5296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5297     void setScissorWithCount( uint32_t                             scissorCount,
5298                               const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
5299                               Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5300 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5301     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5302     void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
5303                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5304 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5305 
5306     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5307     void bindVertexBuffers2( uint32_t                                 firstBinding,
5308                              uint32_t                                 bindingCount,
5309                              const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
5310                              const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5311                              const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
5312                              const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
5313                              Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5314 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5315     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5316     void bindVertexBuffers2(
5317       uint32_t                                                                                 firstBinding,
5318       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
5319       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
5320       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5321       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5322       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5323 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5324 
5325     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5326     void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
5327                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5328 
5329     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5330     void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
5331                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5332 
5333     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5334     void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
5335                             Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5336 
5337     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5338     void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
5339                                    Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5340 
5341     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5342     void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
5343                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5344 
5345     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5346     void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5347                        VULKAN_HPP_NAMESPACE::StencilOp        failOp,
5348                        VULKAN_HPP_NAMESPACE::StencilOp        passOp,
5349                        VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
5350                        VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
5351                        Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5352 
5353     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5354     void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
5355                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5356 
5357     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5358     void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
5359                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5360 
5361     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5362     void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
5363                                     Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5364 
5365     //=== VK_EXT_debug_marker ===
5366 
5367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5368     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
5369                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5370 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5371     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5372     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
5373                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5374 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5375 
5376     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5377     void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5378 
5379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5380     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
5381                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5382 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5383     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5384     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
5385                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5386 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5387 
5388     //=== VK_KHR_video_queue ===
5389 
5390     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5391     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
5392                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5393 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5394     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5395     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo,
5396                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5397 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5398 
5399     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5400     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
5401                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5404     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo,
5405                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5406 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5407 
5408     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5409     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
5410                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5411 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5412     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5413     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo,
5414                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5415 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5416 
5417     //=== VK_KHR_video_decode_queue ===
5418 
5419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5420     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo,
5421                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5422 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5423     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5424     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo,
5425                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5426 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5427 
5428     //=== VK_EXT_transform_feedback ===
5429 
5430     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5431     void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
5432                                           uint32_t                                 bindingCount,
5433                                           const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
5434                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5435                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
5436                                           Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5437 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5438     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5439     void bindTransformFeedbackBuffersEXT( uint32_t                                                                         firstBinding,
5440                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
5441                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5442                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes
5443                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5444                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5446 
5447     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5448     void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
5449                                     uint32_t                                 counterBufferCount,
5450                                     const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
5451                                     const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
5452                                     Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5453 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5454     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5455     void beginTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,
5456                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5457                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5458                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5459                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5460 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5461 
5462     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5463     void endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
5464                                   uint32_t                                 counterBufferCount,
5465                                   const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
5466                                   const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
5467                                   Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5468 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5469     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5470     void endTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,
5471                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5472                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5473                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5474                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5475 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5476 
5477     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5478     void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
5479                                uint32_t                                query,
5480                                VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
5481                                uint32_t                                index,
5482                                Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5483 
5484     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5485     void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5486                              uint32_t                        query,
5487                              uint32_t                        index,
5488                              Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5489 
5490     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5491     void drawIndirectByteCountEXT( uint32_t                         instanceCount,
5492                                    uint32_t                         firstInstance,
5493                                    VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
5494                                    VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
5495                                    uint32_t                         counterOffset,
5496                                    uint32_t                         vertexStride,
5497                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5498 
5499     //=== VK_NVX_binary_import ===
5500 
5501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5502     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
5503                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5504 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5505     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5506     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo,
5507                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5508 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5509 
5510     //=== VK_AMD_draw_indirect_count ===
5511 
5512     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5513     void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5514                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
5515                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5516                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5517                                uint32_t                         maxDrawCount,
5518                                uint32_t                         stride,
5519                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5520 
5521     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5522     void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5523                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
5524                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5525                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5526                                       uint32_t                         maxDrawCount,
5527                                       uint32_t                         stride,
5528                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5529 
5530     //=== VK_KHR_dynamic_rendering ===
5531 
5532     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5533     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
5534                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5535 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5536     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5537     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
5538                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5539 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5540 
5541     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5542     void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5543 
5544     //=== VK_KHR_device_group ===
5545 
5546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5547     void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5548 
5549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5550     void dispatchBaseKHR( uint32_t           baseGroupX,
5551                           uint32_t           baseGroupY,
5552                           uint32_t           baseGroupZ,
5553                           uint32_t           groupCountX,
5554                           uint32_t           groupCountY,
5555                           uint32_t           groupCountZ,
5556                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5557 
5558     //=== VK_KHR_push_descriptor ===
5559 
5560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5561     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
5562                                VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
5563                                uint32_t                                         set,
5564                                uint32_t                                         descriptorWriteCount,
5565                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
5566                                Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5567 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5568     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5569     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                                  pipelineBindPoint,
5570                                VULKAN_HPP_NAMESPACE::PipelineLayout                                                     layout,
5571                                uint32_t                                                                                 set,
5572                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
5573                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5574 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5575 
5576     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5577     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5578                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
5579                                            uint32_t                                       set,
5580                                            const void *                                   pData,
5581                                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5582 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5583     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5584     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5585                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
5586                                            uint32_t                                       set,
5587                                            DataType const &                               data,
5588                                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5589 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5590 
5591     //=== VK_EXT_conditional_rendering ===
5592 
5593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5594     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
5595                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5596 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5597     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5598     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
5599                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5600 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5601 
5602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5603     void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5604 
5605     //=== VK_NV_clip_space_w_scaling ===
5606 
5607     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5608     void setViewportWScalingNV( uint32_t                                         firstViewport,
5609                                 uint32_t                                         viewportCount,
5610                                 const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
5611                                 Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5612 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5613     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5614     void setViewportWScalingNV( uint32_t                                                                                 firstViewport,
5615                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
5616                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5617 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5618 
5619     //=== VK_EXT_discard_rectangles ===
5620 
5621     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5622     void setDiscardRectangleEXT( uint32_t                             firstDiscardRectangle,
5623                                  uint32_t                             discardRectangleCount,
5624                                  const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
5625                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5626 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5627     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5628     void setDiscardRectangleEXT( uint32_t                                                                     firstDiscardRectangle,
5629                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
5630                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5631 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5632 
5633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5634     void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable,
5635                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5636 
5637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5638     void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode,
5639                                      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5640 
5641     //=== VK_KHR_create_renderpass2 ===
5642 
5643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5644     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
5645                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
5646                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5647 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5648     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5649     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5650                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
5651                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5652 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5653 
5654     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5655     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
5656                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
5657                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5658 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5659     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5660     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5661                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
5662                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5663 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5664 
5665     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5666     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
5667                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5668 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5670     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
5671                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5672 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5673 
5674     //=== VK_EXT_debug_utils ===
5675 
5676     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5677     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
5678                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5680     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5681     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
5682                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5683 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5684 
5685     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5686     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5687 
5688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5689     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
5690                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5691 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5692     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5693     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
5694                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5695 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5696 
5697 #if defined( VK_ENABLE_BETA_EXTENSIONS )
5698     //=== VK_AMDX_shader_enqueue ===
5699 
5700     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5701     void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
5702                                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5703 
5704     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5705     void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
5706                             const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,
5707                             Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5708 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5709     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5710     void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
5711                             const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,
5712                             Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5713 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5714 
5715     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5716     void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
5717                                     const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,
5718                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5719 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5720     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5721     void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
5722                                     const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,
5723                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5724 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5725 
5726     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5727     void dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
5728                                          VULKAN_HPP_NAMESPACE::DeviceAddress countInfo,
5729                                          Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5730 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
5731 
5732     //=== VK_EXT_sample_locations ===
5733 
5734     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5735     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
5736                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5737 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5738     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5739     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo,
5740                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5741 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5742 
5743     //=== VK_KHR_acceleration_structure ===
5744 
5745     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5746     void buildAccelerationStructuresKHR( uint32_t                                                                     infoCount,
5747                                          const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
5748                                          const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
5749                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5750 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5751     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5752     void buildAccelerationStructuresKHR(
5753       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
5754       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
5755       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5756 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5757 
5758     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5759     void buildAccelerationStructuresIndirectKHR( uint32_t                                                                infoCount,
5760                                                  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
5761                                                  const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
5762                                                  const uint32_t *                                                        pIndirectStrides,
5763                                                  const uint32_t * const *                                                ppMaxPrimitiveCounts,
5764                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5765 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5767     void buildAccelerationStructuresIndirectKHR(
5768       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
5769       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
5770       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                                                        indirectStrides,
5771       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
5772       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5773 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5774 
5775     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5776     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
5777                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5778 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5779     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5780     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
5781                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5782 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5783 
5784     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5785     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
5786                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5787 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5789     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
5790                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5791 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5792 
5793     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5794     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
5795                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5798     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
5799                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5800 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5801 
5802     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5803     void writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,
5804                                                    const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
5805                                                    VULKAN_HPP_NAMESPACE::QueryType                        queryType,
5806                                                    VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,
5807                                                    uint32_t                                               firstQuery,
5808                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5809 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5811     void writeAccelerationStructuresPropertiesKHR(
5812       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
5813       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,
5814       VULKAN_HPP_NAMESPACE::QueryPool                                                                queryPool,
5815       uint32_t                                                                                       firstQuery,
5816       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5817 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5818 
5819     //=== VK_KHR_ray_tracing_pipeline ===
5820 
5821     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5822     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5823                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5824                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5825                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5826                        uint32_t                                                    width,
5827                        uint32_t                                                    height,
5828                        uint32_t                                                    depth,
5829                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5831     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5832     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5833                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5834                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5835                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5836                        uint32_t                                                    width,
5837                        uint32_t                                                    height,
5838                        uint32_t                                                    depth,
5839                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5840 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5841 
5842     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5843     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5844                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5845                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5846                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5847                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
5848                                Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5851     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5852                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5853                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5854                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5855                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
5856                                Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5857 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5858 
5859     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5860     void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5861 
5862     //=== VK_NV_shading_rate_image ===
5863 
5864     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5865     void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
5866                                  VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
5867                                  Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5868 
5869     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5870     void setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,
5871                                           uint32_t                                           viewportCount,
5872                                           const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
5873                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5875     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5876     void setViewportShadingRatePaletteNV( uint32_t                                                                                   firstViewport,
5877                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
5878                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5879 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5880 
5881     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5882     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,
5883                                  uint32_t                                                customSampleOrderCount,
5884                                  const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
5885                                  Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5886 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5887     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5888     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                                                   sampleOrderType,
5889                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
5890                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5891 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5892 
5893     //=== VK_NV_ray_tracing ===
5894 
5895     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5896     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
5897                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
5898                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
5899                                        VULKAN_HPP_NAMESPACE::Bool32                              update,
5900                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
5901                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
5902                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,
5903                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
5904                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5905 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5907     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
5908                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
5909                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
5910                                        VULKAN_HPP_NAMESPACE::Bool32                              update,
5911                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
5912                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
5913                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,
5914                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
5915                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5916 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5917 
5918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5919     void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
5920                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
5921                                       VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
5922                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5923 
5924     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5925     void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
5926                       VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
5927                       VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
5928                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
5929                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
5930                       VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
5931                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
5932                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
5933                       VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
5934                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
5935                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
5936                       uint32_t                         width,
5937                       uint32_t                         height,
5938                       uint32_t                         depth,
5939                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5940 
5941     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5942     void writeAccelerationStructuresPropertiesNV( uint32_t                                              accelerationStructureCount,
5943                                                   const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
5944                                                   VULKAN_HPP_NAMESPACE::QueryType                       queryType,
5945                                                   VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,
5946                                                   uint32_t                                              firstQuery,
5947                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5948 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5949     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5950     void writeAccelerationStructuresPropertiesNV(
5951       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
5952       VULKAN_HPP_NAMESPACE::QueryType                                                               queryType,
5953       VULKAN_HPP_NAMESPACE::QueryPool                                                               queryPool,
5954       uint32_t                                                                                      firstQuery,
5955       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5956 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5957 
5958     //=== VK_KHR_draw_indirect_count ===
5959 
5960     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5961     void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5962                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
5963                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5964                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5965                                uint32_t                         maxDrawCount,
5966                                uint32_t                         stride,
5967                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5968 
5969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5970     void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5971                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
5972                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5973                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5974                                       uint32_t                         maxDrawCount,
5975                                       uint32_t                         stride,
5976                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5977 
5978     //=== VK_AMD_buffer_marker ===
5979 
5980     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5981     void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
5982                                VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
5983                                VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
5984                                uint32_t                                    marker,
5985                                Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5986 
5987     //=== VK_NV_mesh_shader ===
5988 
5989     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5990     void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5991 
5992     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5993     void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5994                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,
5995                                   uint32_t                         drawCount,
5996                                   uint32_t                         stride,
5997                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5998 
5999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6000     void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6001                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
6002                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
6003                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
6004                                        uint32_t                         maxDrawCount,
6005                                        uint32_t                         stride,
6006                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6007 
6008     //=== VK_NV_scissor_exclusive ===
6009 
6010     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6011     void setExclusiveScissorEnableNV( uint32_t                             firstExclusiveScissor,
6012                                       uint32_t                             exclusiveScissorCount,
6013                                       const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables,
6014                                       Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6015 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6016     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6017     void setExclusiveScissorEnableNV( uint32_t                                                                     firstExclusiveScissor,
6018                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables,
6019                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6020 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6021 
6022     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6023     void setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,
6024                                 uint32_t                             exclusiveScissorCount,
6025                                 const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
6026                                 Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6028     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6029     void setExclusiveScissorNV( uint32_t                                                                     firstExclusiveScissor,
6030                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
6031                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6032 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6033 
6034     //=== VK_NV_device_diagnostic_checkpoints ===
6035 
6036     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6037     void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6039     template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6040     void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,
6041                           Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6042 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6043 
6044     //=== VK_INTEL_performance_query ===
6045 
6046     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6047     VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
6048                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6049 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6051     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6052       setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo,
6053                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6054 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6055 
6056     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6057     VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
6058                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6060     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6061     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6062       setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo,
6063                                        Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6064 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6065 
6066     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6067     VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
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     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6072       setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo,
6073                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6074 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6075 
6076     //=== VK_KHR_fragment_shading_rate ===
6077 
6078     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6079     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
6080                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
6081                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6082 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6083     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6084     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D &                       fragmentSize,
6085                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
6086                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6087 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6088 
6089     //=== VK_KHR_dynamic_rendering_local_read ===
6090 
6091     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6092     void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR * pLocationInfo,
6093                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6094 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6095     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6096     void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR & locationInfo,
6097                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6098 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6099 
6100     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6101     void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR * pLocationInfo,
6102                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6104     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6105     void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR & locationInfo,
6106                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6107 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6108 
6109     //=== VK_EXT_line_rasterization ===
6110 
6111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6112     void setLineStippleEXT( uint32_t           lineStippleFactor,
6113                             uint16_t           lineStipplePattern,
6114                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6115 
6116     //=== VK_EXT_extended_dynamic_state ===
6117 
6118     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6119     void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6120 
6121     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6122     void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6123 
6124     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6125     void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
6126                                   Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6127 
6128     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6129     void setViewportWithCountEXT( uint32_t                               viewportCount,
6130                                   const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
6131                                   Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6132 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6133     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6134     void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
6135                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6136 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6137 
6138     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6139     void setScissorWithCountEXT( uint32_t                             scissorCount,
6140                                  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
6141                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6142 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6143     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6144     void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
6145                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6147 
6148     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6149     void bindVertexBuffers2EXT( uint32_t                                 firstBinding,
6150                                 uint32_t                                 bindingCount,
6151                                 const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
6152                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
6153                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
6154                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
6155                                 Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6156 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6157     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6158     void bindVertexBuffers2EXT(
6159       uint32_t                                                                                 firstBinding,
6160       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
6161       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
6162       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6163       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6164       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6165 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6166 
6167     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6168     void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
6169                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6170 
6171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6172     void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
6173                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6174 
6175     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6176     void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
6177                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6178 
6179     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6180     void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
6181                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6182 
6183     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6184     void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
6185                                   Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6186 
6187     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6188     void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
6189                           VULKAN_HPP_NAMESPACE::StencilOp        failOp,
6190                           VULKAN_HPP_NAMESPACE::StencilOp        passOp,
6191                           VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
6192                           VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
6193                           Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6194 
6195     //=== VK_NV_device_generated_commands ===
6196 
6197     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6198     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
6199                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6200 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6201     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6202     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
6203                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6204 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6205 
6206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6207     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
6208                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
6209                                      Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6210 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6211     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6212     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
6213                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
6214                                      Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6215 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6216 
6217     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6218     void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6219                                     VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
6220                                     uint32_t                                groupIndex,
6221                                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6222 
6223     //=== VK_EXT_depth_bias_control ===
6224 
6225     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6226     void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT * pDepthBiasInfo,
6227                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6228 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6229     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6230     void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo,
6231                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6232 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6233 
6234     //=== VK_KHR_video_encode_queue ===
6235 
6236     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6237     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
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 encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo,
6242                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6243 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6244 
6245 #if defined( VK_ENABLE_BETA_EXTENSIONS )
6246     //=== VK_NV_cuda_kernel_launch ===
6247 
6248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6249     void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV * pLaunchInfo,
6250                              Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6251 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6252     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6253     void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo,
6254                              Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6255 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6256 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
6257 
6258     //=== VK_KHR_synchronization2 ===
6259 
6260     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6261     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
6262                        const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
6263                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6264 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6265     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6266     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
6267                        const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
6268                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6269 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6270 
6271     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6272     void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event               event,
6273                          VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,
6274                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6275 
6276     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6277     void waitEvents2KHR( uint32_t                                     eventCount,
6278                          const VULKAN_HPP_NAMESPACE::Event *          pEvents,
6279                          const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
6280                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6281 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6282     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6283     void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &          events,
6284                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,
6285                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6287 
6288     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6289     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
6290                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6291 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6292     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6293     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
6294                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6295 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6296 
6297     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6298     void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
6299                              VULKAN_HPP_NAMESPACE::QueryPool           queryPool,
6300                              uint32_t                                  query,
6301                              Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6302 
6303     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6304     void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
6305                                 VULKAN_HPP_NAMESPACE::Buffer              dstBuffer,
6306                                 VULKAN_HPP_NAMESPACE::DeviceSize          dstOffset,
6307                                 uint32_t                                  marker,
6308                                 Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6309 
6310     //=== VK_EXT_descriptor_buffer ===
6311 
6312     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6313     void bindDescriptorBuffersEXT( uint32_t                                                     bufferCount,
6314                                    const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos,
6315                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6316 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6317     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6318     void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos,
6319                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6320 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6321 
6322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6323     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint  pipelineBindPoint,
6324                                         VULKAN_HPP_NAMESPACE::PipelineLayout     layout,
6325                                         uint32_t                                 firstSet,
6326                                         uint32_t                                 setCount,
6327                                         const uint32_t *                         pBufferIndices,
6328                                         const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
6329                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6331     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6332     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                          pipelineBindPoint,
6333                                         VULKAN_HPP_NAMESPACE::PipelineLayout                                             layout,
6334                                         uint32_t                                                                         firstSet,
6335                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                         bufferIndices,
6336                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
6337                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6338 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6339 
6340     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6341     void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6342                                                   VULKAN_HPP_NAMESPACE::PipelineLayout    layout,
6343                                                   uint32_t                                set,
6344                                                   Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6345 
6346     //=== VK_NV_fragment_shading_rate_enums ===
6347 
6348     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6349     void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
6350                                        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
6351                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6352 
6353     //=== VK_EXT_mesh_shader ===
6354 
6355     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6356     void drawMeshTasksEXT( uint32_t           groupCountX,
6357                            uint32_t           groupCountY,
6358                            uint32_t           groupCountZ,
6359                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6360 
6361     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6362     void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6363                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
6364                                    uint32_t                         drawCount,
6365                                    uint32_t                         stride,
6366                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6367 
6368     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6369     void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6370                                         VULKAN_HPP_NAMESPACE::DeviceSize offset,
6371                                         VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
6372                                         VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
6373                                         uint32_t                         maxDrawCount,
6374                                         uint32_t                         stride,
6375                                         Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6376 
6377     //=== VK_KHR_copy_commands2 ===
6378 
6379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6380     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
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 copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
6385                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6386 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6387 
6388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6389     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
6390                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6391 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6392     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6393     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
6394                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6395 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6396 
6397     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6398     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
6399                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6400 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6401     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6402     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
6403                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6404 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6405 
6406     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6407     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
6408                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6409 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6410     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6411     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
6412                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6413 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6414 
6415     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6416     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
6417                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6418 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6420     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
6421                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6422 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6423 
6424     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6425     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
6426                            Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6427 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6428     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6429     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
6430                            Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6431 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6432 
6433     //=== VK_EXT_vertex_input_dynamic_state ===
6434 
6435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6436     void setVertexInputEXT( uint32_t                                                          vertexBindingDescriptionCount,
6437                             const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT *   pVertexBindingDescriptions,
6438                             uint32_t                                                          vertexAttributeDescriptionCount,
6439                             const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
6440                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6441 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6442     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6443     void
6444       setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
6445                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
6446                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6447 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6448 
6449     //=== VK_HUAWEI_subpass_shading ===
6450 
6451     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6452     void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6453 
6454     //=== VK_HUAWEI_invocation_mask ===
6455 
6456     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6457     void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView   imageView,
6458                                    VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
6459                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6460 
6461     //=== VK_EXT_extended_dynamic_state2 ===
6462 
6463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6464     void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6465 
6466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6467     void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
6468                                         Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6469 
6470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6471     void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
6472                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6473 
6474     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6475     void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6476 
6477     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6478     void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
6479                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6480 
6481     //=== VK_EXT_color_write_enable ===
6482 
6483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6484     void setColorWriteEnableEXT( uint32_t                             attachmentCount,
6485                                  const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
6486                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6487 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6488     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6489     void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
6490                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6491 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6492 
6493     //=== VK_KHR_ray_tracing_maintenance1 ===
6494 
6495     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6496     void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
6497                                 Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6498 
6499     //=== VK_EXT_multi_draw ===
6500 
6501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6502     void drawMultiEXT( uint32_t                                       drawCount,
6503                        const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,
6504                        uint32_t                                       instanceCount,
6505                        uint32_t                                       firstInstance,
6506                        uint32_t                                       stride,
6507                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6508 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6510     void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
6511                        uint32_t                                                                                      instanceCount,
6512                        uint32_t                                                                                      firstInstance,
6513                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6514 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6515 
6516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6517     void drawMultiIndexedEXT( uint32_t                                              drawCount,
6518                               const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,
6519                               uint32_t                                              instanceCount,
6520                               uint32_t                                              firstInstance,
6521                               uint32_t                                              stride,
6522                               const int32_t *                                       pVertexOffset,
6523                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6524 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6526     void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
6527                               uint32_t                                                                                             instanceCount,
6528                               uint32_t                                                                                             firstInstance,
6529                               Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6530                               Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6531 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6532 
6533     //=== VK_EXT_opacity_micromap ===
6534 
6535     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6536     void buildMicromapsEXT( uint32_t                                           infoCount,
6537                             const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,
6538                             Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6539 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6540     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6541     void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,
6542                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6543 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6544 
6545     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6546     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,
6547                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6548 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6550     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,
6551                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6552 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6553 
6554     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6555     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,
6556                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6557 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6558     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6559     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,
6560                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6561 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6562 
6563     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6564     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,
6565                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6568     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,
6569                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6571 
6572     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6573     void writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,
6574                                       const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
6575                                       VULKAN_HPP_NAMESPACE::QueryType           queryType,
6576                                       VULKAN_HPP_NAMESPACE::QueryPool           queryPool,
6577                                       uint32_t                                  firstQuery,
6578                                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6579 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6580     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6581     void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
6582                                       VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,
6583                                       VULKAN_HPP_NAMESPACE::QueryPool                                                   queryPool,
6584                                       uint32_t                                                                          firstQuery,
6585                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6586 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6587 
6588     //=== VK_HUAWEI_cluster_culling_shader ===
6589 
6590     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6591     void drawClusterHUAWEI( uint32_t           groupCountX,
6592                             uint32_t           groupCountY,
6593                             uint32_t           groupCountZ,
6594                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6595 
6596     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6597     void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6598                                     VULKAN_HPP_NAMESPACE::DeviceSize offset,
6599                                     Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6600 
6601     //=== VK_NV_copy_memory_indirect ===
6602 
6603     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6604     void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,
6605                                uint32_t                            copyCount,
6606                                uint32_t                            stride,
6607                                Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6608 
6609     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6610     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                  copyBufferAddress,
6611                                       uint32_t                                             copyCount,
6612                                       uint32_t                                             stride,
6613                                       VULKAN_HPP_NAMESPACE::Image                          dstImage,
6614                                       VULKAN_HPP_NAMESPACE::ImageLayout                    dstImageLayout,
6615                                       const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources,
6616                                       Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6617 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6619     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                                                          copyBufferAddress,
6620                                       uint32_t                                                                                     stride,
6621                                       VULKAN_HPP_NAMESPACE::Image                                                                  dstImage,
6622                                       VULKAN_HPP_NAMESPACE::ImageLayout                                                            dstImageLayout,
6623                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources,
6624                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6625 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6626 
6627     //=== VK_NV_memory_decompression ===
6628 
6629     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6630     void decompressMemoryNV( uint32_t                                               decompressRegionCount,
6631                              const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions,
6632                              Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6633 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6634     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6635     void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions,
6636                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6637 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6638 
6639     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6640     void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,
6641                                           VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,
6642                                           uint32_t                            stride,
6643                                           Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6644 
6645     //=== VK_NV_device_generated_commands_compute ===
6646 
6647     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6648     void updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6649                                          VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
6650                                          Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6651 
6652     //=== VK_EXT_extended_dynamic_state3 ===
6653 
6654     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6655     void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable,
6656                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6657 
6658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6659     void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode,
6660                             Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6661 
6662     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6663     void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples,
6664                                      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6665 
6666     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6667     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
6668                            const VULKAN_HPP_NAMESPACE::SampleMask *  pSampleMask,
6669                            Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6670 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6671     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6672     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits                                        samples,
6673                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask,
6674                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6675 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6676 
6677     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6678     void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable,
6679                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6680 
6681     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6682     void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable,
6683                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6684 
6685     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6686     void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable,
6687                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6688 
6689     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6690     void setColorBlendEnableEXT( uint32_t                             firstAttachment,
6691                                  uint32_t                             attachmentCount,
6692                                  const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables,
6693                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6694 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6695     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6696     void setColorBlendEnableEXT( uint32_t                                                                     firstAttachment,
6697                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables,
6698                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6699 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6700 
6701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6702     void setColorBlendEquationEXT( uint32_t                                            firstAttachment,
6703                                    uint32_t                                            attachmentCount,
6704                                    const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations,
6705                                    Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6706 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6707     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6708     void setColorBlendEquationEXT( uint32_t                                                                                    firstAttachment,
6709                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations,
6710                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6711 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6712 
6713     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6714     void setColorWriteMaskEXT( uint32_t                                          firstAttachment,
6715                                uint32_t                                          attachmentCount,
6716                                const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks,
6717                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6718 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6719     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6720     void setColorWriteMaskEXT( uint32_t                                                                                  firstAttachment,
6721                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks,
6722                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6723 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6724 
6725     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6726     void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin,
6727                                          Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6728 
6729     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6730     void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6731 
6732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6733     void setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode,
6734                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6735 
6736     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6737     void setExtraPrimitiveOverestimationSizeEXT( float              extraPrimitiveOverestimationSize,
6738                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6739 
6740     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6741     void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable,
6742                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6743 
6744     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6745     void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable,
6746                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6747 
6748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6749     void setColorBlendAdvancedEXT( uint32_t                                            firstAttachment,
6750                                    uint32_t                                            attachmentCount,
6751                                    const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced,
6752                                    Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6753 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6754     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6755     void setColorBlendAdvancedEXT( uint32_t                                                                                    firstAttachment,
6756                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced,
6757                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6758 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6759 
6760     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6761     void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode,
6762                                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6763 
6764     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6765     void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode,
6766                                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6767 
6768     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6769     void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable,
6770                                   Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6771 
6772     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6773     void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne,
6774                                           Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6775 
6776     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6777     void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable,
6778                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6779 
6780     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6781     void setViewportSwizzleNV( uint32_t                                        firstViewport,
6782                                uint32_t                                        viewportCount,
6783                                const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles,
6784                                Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6785 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6786     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6787     void setViewportSwizzleNV( uint32_t                                                                                firstViewport,
6788                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles,
6789                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6790 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6791 
6792     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6793     void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable,
6794                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6795 
6796     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6797     void setCoverageToColorLocationNV( uint32_t           coverageToColorLocation,
6798                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6799 
6800     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6801     void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode,
6802                                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6803 
6804     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6805     void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable,
6806                                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6807 
6808     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6809     void setCoverageModulationTableNV( uint32_t           coverageModulationTableCount,
6810                                        const float *      pCoverageModulationTable,
6811                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6812 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6813     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6814     void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable,
6815                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6816 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6817 
6818     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6819     void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable,
6820                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6821 
6822     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6823     void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable,
6824                                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6825 
6826     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6827     void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode,
6828                                      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6829 
6830     //=== VK_NV_optical_flow ===
6831 
6832     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6833     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
6834                                const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo,
6835                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6836 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6837     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6838     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
6839                                const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo,
6840                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6842 
6843     //=== VK_KHR_maintenance5 ===
6844 
6845     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6846     void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6847                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
6848                               VULKAN_HPP_NAMESPACE::DeviceSize size,
6849                               VULKAN_HPP_NAMESPACE::IndexType  indexType,
6850                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6851 
6852     //=== VK_EXT_shader_object ===
6853 
6854     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6855     void bindShadersEXT( uint32_t                                          stageCount,
6856                          const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits * pStages,
6857                          const VULKAN_HPP_NAMESPACE::ShaderEXT *           pShaders,
6858                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6859 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6860     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6861     void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages,
6862                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const &           shaders,
6863                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6864 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6865 
6866     //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
6867 
6868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6869     void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask,
6870                                              Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6871 
6872     //=== VK_KHR_line_rasterization ===
6873 
6874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6875     void setLineStippleKHR( uint32_t           lineStippleFactor,
6876                             uint16_t           lineStipplePattern,
6877                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6878 
6879     //=== VK_KHR_maintenance6 ===
6880 
6881     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6882     void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR * pBindDescriptorSetsInfo,
6883                                  Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6884 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6885     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6886     void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR & bindDescriptorSetsInfo,
6887                                  Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6888 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6889 
6890     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6891     void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR * pPushConstantsInfo,
6892                             Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6893 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6894     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6895     void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR & pushConstantsInfo,
6896                             Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6897 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6898 
6899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6900     void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR * pPushDescriptorSetInfo,
6901                                 Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6902 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6903     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6904     void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR & pushDescriptorSetInfo,
6905                                 Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6906 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6907 
6908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6909     void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR * pPushDescriptorSetWithTemplateInfo,
6910                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6911 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6912     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6913     void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR & pushDescriptorSetWithTemplateInfo,
6914                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6915 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6916 
6917     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6918     void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo,
6919                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6920 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6921     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6922     void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo,
6923                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6924 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6925 
6926     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6927     void bindDescriptorBufferEmbeddedSamplers2EXT(
6928       const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo,
6929       Dispatch const & d                                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6930 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6931     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6932     void bindDescriptorBufferEmbeddedSamplers2EXT(
6933       const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo,
6934       Dispatch const & d                                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6935 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6936 
operator VkCommandBuffer() const6937     operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
6938     {
6939       return m_commandBuffer;
6940     }
6941 
operator bool() const6942     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6943     {
6944       return m_commandBuffer != VK_NULL_HANDLE;
6945     }
6946 
operator !() const6947     bool operator!() const VULKAN_HPP_NOEXCEPT
6948     {
6949       return m_commandBuffer == VK_NULL_HANDLE;
6950     }
6951 
6952   private:
6953     VkCommandBuffer m_commandBuffer = {};
6954   };
6955 
6956   template <>
6957   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
6958   {
6959     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
6960   };
6961 
6962   template <>
6963   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
6964   {
6965     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
6966   };
6967 
6968 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
6969   template <>
6970   struct CppType<VkCommandBuffer, VK_NULL_HANDLE>
6971   {
6972     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
6973   };
6974 #endif
6975 
6976   template <>
6977   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
6978   {
6979     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6980   };
6981 
6982   class DeviceMemory
6983   {
6984   public:
6985     using CType      = VkDeviceMemory;
6986     using NativeType = VkDeviceMemory;
6987 
6988     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
6989     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6990       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
6991 
6992   public:
6993     DeviceMemory()                                       = default;
6994     DeviceMemory( DeviceMemory const & rhs )             = default;
6995     DeviceMemory & operator=( DeviceMemory const & rhs ) = default;
6996     DeviceMemory( DeviceMemory && rhs )                  = default;
6997     DeviceMemory & operator=( DeviceMemory && rhs )      = default;
6998 
DeviceMemory(std::nullptr_t)6999     VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7000 
DeviceMemory(VkDeviceMemory deviceMemory)7001     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}
7002 
7003 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDeviceMemory deviceMemory)7004     DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
7005     {
7006       m_deviceMemory = deviceMemory;
7007       return *this;
7008     }
7009 #endif
7010 
operator =(std::nullptr_t)7011     DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7012     {
7013       m_deviceMemory = {};
7014       return *this;
7015     }
7016 
7017 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7018     auto operator<=>( DeviceMemory const & ) const = default;
7019 #else
operator ==(DeviceMemory const & rhs) const7020     bool                                 operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
7021     {
7022       return m_deviceMemory == rhs.m_deviceMemory;
7023     }
7024 
operator !=(DeviceMemory const & rhs) const7025     bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
7026     {
7027       return m_deviceMemory != rhs.m_deviceMemory;
7028     }
7029 
operator <(DeviceMemory const & rhs) const7030     bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
7031     {
7032       return m_deviceMemory < rhs.m_deviceMemory;
7033     }
7034 #endif
7035 
operator VkDeviceMemory() const7036     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
7037     {
7038       return m_deviceMemory;
7039     }
7040 
operator bool() const7041     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7042     {
7043       return m_deviceMemory != VK_NULL_HANDLE;
7044     }
7045 
operator !() const7046     bool operator!() const VULKAN_HPP_NOEXCEPT
7047     {
7048       return m_deviceMemory == VK_NULL_HANDLE;
7049     }
7050 
7051   private:
7052     VkDeviceMemory m_deviceMemory = {};
7053   };
7054 
7055   template <>
7056   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
7057   {
7058     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
7059   };
7060 
7061   template <>
7062   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
7063   {
7064     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
7065   };
7066 
7067 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7068   template <>
7069   struct CppType<VkDeviceMemory, VK_NULL_HANDLE>
7070   {
7071     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
7072   };
7073 #endif
7074 
7075   template <>
7076   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
7077   {
7078     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7079   };
7080 
7081   class VideoSessionKHR
7082   {
7083   public:
7084     using CType      = VkVideoSessionKHR;
7085     using NativeType = VkVideoSessionKHR;
7086 
7087     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
7088     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7089       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7090 
7091   public:
7092     VideoSessionKHR()                                          = default;
7093     VideoSessionKHR( VideoSessionKHR const & rhs )             = default;
7094     VideoSessionKHR & operator=( VideoSessionKHR const & rhs ) = default;
7095     VideoSessionKHR( VideoSessionKHR && rhs )                  = default;
7096     VideoSessionKHR & operator=( VideoSessionKHR && rhs )      = default;
7097 
VideoSessionKHR(std::nullptr_t)7098     VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7099 
VideoSessionKHR(VkVideoSessionKHR videoSessionKHR)7100     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}
7101 
7102 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkVideoSessionKHR videoSessionKHR)7103     VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
7104     {
7105       m_videoSessionKHR = videoSessionKHR;
7106       return *this;
7107     }
7108 #endif
7109 
operator =(std::nullptr_t)7110     VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7111     {
7112       m_videoSessionKHR = {};
7113       return *this;
7114     }
7115 
7116 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7117     auto operator<=>( VideoSessionKHR const & ) const = default;
7118 #else
operator ==(VideoSessionKHR const & rhs) const7119     bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7120     {
7121       return m_videoSessionKHR == rhs.m_videoSessionKHR;
7122     }
7123 
operator !=(VideoSessionKHR const & rhs) const7124     bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7125     {
7126       return m_videoSessionKHR != rhs.m_videoSessionKHR;
7127     }
7128 
operator <(VideoSessionKHR const & rhs) const7129     bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7130     {
7131       return m_videoSessionKHR < rhs.m_videoSessionKHR;
7132     }
7133 #endif
7134 
operator VkVideoSessionKHR() const7135     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
7136     {
7137       return m_videoSessionKHR;
7138     }
7139 
operator bool() const7140     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7141     {
7142       return m_videoSessionKHR != VK_NULL_HANDLE;
7143     }
7144 
operator !() const7145     bool operator!() const VULKAN_HPP_NOEXCEPT
7146     {
7147       return m_videoSessionKHR == VK_NULL_HANDLE;
7148     }
7149 
7150   private:
7151     VkVideoSessionKHR m_videoSessionKHR = {};
7152   };
7153 
7154   template <>
7155   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
7156   {
7157     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
7158   };
7159 
7160 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7161   template <>
7162   struct CppType<VkVideoSessionKHR, VK_NULL_HANDLE>
7163   {
7164     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
7165   };
7166 #endif
7167 
7168   template <>
7169   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
7170   {
7171     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7172   };
7173 
7174   class DeferredOperationKHR
7175   {
7176   public:
7177     using CType      = VkDeferredOperationKHR;
7178     using NativeType = VkDeferredOperationKHR;
7179 
7180     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
7181     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7182       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7183 
7184   public:
7185     DeferredOperationKHR()                                               = default;
7186     DeferredOperationKHR( DeferredOperationKHR const & rhs )             = default;
7187     DeferredOperationKHR & operator=( DeferredOperationKHR const & rhs ) = default;
7188     DeferredOperationKHR( DeferredOperationKHR && rhs )                  = default;
7189     DeferredOperationKHR & operator=( DeferredOperationKHR && rhs )      = default;
7190 
DeferredOperationKHR(std::nullptr_t)7191     VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7192 
DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR)7193     VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
7194       : m_deferredOperationKHR( deferredOperationKHR )
7195     {
7196     }
7197 
7198 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDeferredOperationKHR deferredOperationKHR)7199     DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
7200     {
7201       m_deferredOperationKHR = deferredOperationKHR;
7202       return *this;
7203     }
7204 #endif
7205 
operator =(std::nullptr_t)7206     DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7207     {
7208       m_deferredOperationKHR = {};
7209       return *this;
7210     }
7211 
7212 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7213     auto operator<=>( DeferredOperationKHR const & ) const = default;
7214 #else
operator ==(DeferredOperationKHR const & rhs) const7215     bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7216     {
7217       return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
7218     }
7219 
operator !=(DeferredOperationKHR const & rhs) const7220     bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7221     {
7222       return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
7223     }
7224 
operator <(DeferredOperationKHR const & rhs) const7225     bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7226     {
7227       return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
7228     }
7229 #endif
7230 
operator VkDeferredOperationKHR() const7231     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
7232     {
7233       return m_deferredOperationKHR;
7234     }
7235 
operator bool() const7236     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7237     {
7238       return m_deferredOperationKHR != VK_NULL_HANDLE;
7239     }
7240 
operator !() const7241     bool operator!() const VULKAN_HPP_NOEXCEPT
7242     {
7243       return m_deferredOperationKHR == VK_NULL_HANDLE;
7244     }
7245 
7246   private:
7247     VkDeferredOperationKHR m_deferredOperationKHR = {};
7248   };
7249 
7250   template <>
7251   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
7252   {
7253     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
7254   };
7255 
7256 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7257   template <>
7258   struct CppType<VkDeferredOperationKHR, VK_NULL_HANDLE>
7259   {
7260     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
7261   };
7262 #endif
7263 
7264   template <>
7265   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
7266   {
7267     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7268   };
7269 
7270 #if defined( VK_USE_PLATFORM_FUCHSIA )
7271   class BufferCollectionFUCHSIA
7272   {
7273   public:
7274     using CType      = VkBufferCollectionFUCHSIA;
7275     using NativeType = VkBufferCollectionFUCHSIA;
7276 
7277     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
7278     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7279       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
7280 
7281   public:
7282     BufferCollectionFUCHSIA()                                                  = default;
7283     BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & rhs )             = default;
7284     BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & rhs ) = default;
7285     BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs )                  = default;
7286     BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs )      = default;
7287 
BufferCollectionFUCHSIA(std::nullptr_t)7288     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7289 
BufferCollectionFUCHSIA(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)7290     VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
7291       : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
7292     {
7293     }
7294 
7295 #  if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)7296     BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
7297     {
7298       m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
7299       return *this;
7300     }
7301 #  endif
7302 
operator =(std::nullptr_t)7303     BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7304     {
7305       m_bufferCollectionFUCHSIA = {};
7306       return *this;
7307     }
7308 
7309 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7310     auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;
7311 #  else
operator ==(BufferCollectionFUCHSIA const & rhs) const7312     bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
7313     {
7314       return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
7315     }
7316 
operator !=(BufferCollectionFUCHSIA const & rhs) const7317     bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
7318     {
7319       return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
7320     }
7321 
operator <(BufferCollectionFUCHSIA const & rhs) const7322     bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
7323     {
7324       return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
7325     }
7326 #  endif
7327 
operator VkBufferCollectionFUCHSIA() const7328     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
7329     {
7330       return m_bufferCollectionFUCHSIA;
7331     }
7332 
operator bool() const7333     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7334     {
7335       return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
7336     }
7337 
operator !() const7338     bool operator!() const VULKAN_HPP_NOEXCEPT
7339     {
7340       return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
7341     }
7342 
7343   private:
7344     VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
7345   };
7346 
7347   template <>
7348   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>
7349   {
7350     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
7351   };
7352 
7353   template <>
7354   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
7355   {
7356     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
7357   };
7358 
7359 #  if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7360   template <>
7361   struct CppType<VkBufferCollectionFUCHSIA, VK_NULL_HANDLE>
7362   {
7363     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
7364   };
7365 #  endif
7366 
7367   template <>
7368   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
7369   {
7370     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7371   };
7372 #endif /*VK_USE_PLATFORM_FUCHSIA*/
7373 
7374   class BufferView
7375   {
7376   public:
7377     using CType      = VkBufferView;
7378     using NativeType = VkBufferView;
7379 
7380     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
7381     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7382       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
7383 
7384   public:
7385     BufferView()                                     = default;
7386     BufferView( BufferView const & rhs )             = default;
7387     BufferView & operator=( BufferView const & rhs ) = default;
7388     BufferView( BufferView && rhs )                  = default;
7389     BufferView & operator=( BufferView && rhs )      = default;
7390 
BufferView(std::nullptr_t)7391     VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7392 
BufferView(VkBufferView bufferView)7393     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}
7394 
7395 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkBufferView bufferView)7396     BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
7397     {
7398       m_bufferView = bufferView;
7399       return *this;
7400     }
7401 #endif
7402 
operator =(std::nullptr_t)7403     BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7404     {
7405       m_bufferView = {};
7406       return *this;
7407     }
7408 
7409 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7410     auto operator<=>( BufferView const & ) const = default;
7411 #else
operator ==(BufferView const & rhs) const7412     bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7413     {
7414       return m_bufferView == rhs.m_bufferView;
7415     }
7416 
operator !=(BufferView const & rhs) const7417     bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7418     {
7419       return m_bufferView != rhs.m_bufferView;
7420     }
7421 
operator <(BufferView const & rhs) const7422     bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7423     {
7424       return m_bufferView < rhs.m_bufferView;
7425     }
7426 #endif
7427 
operator VkBufferView() const7428     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
7429     {
7430       return m_bufferView;
7431     }
7432 
operator bool() const7433     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7434     {
7435       return m_bufferView != VK_NULL_HANDLE;
7436     }
7437 
operator !() const7438     bool operator!() const VULKAN_HPP_NOEXCEPT
7439     {
7440       return m_bufferView == VK_NULL_HANDLE;
7441     }
7442 
7443   private:
7444     VkBufferView m_bufferView = {};
7445   };
7446 
7447   template <>
7448   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
7449   {
7450     using Type = VULKAN_HPP_NAMESPACE::BufferView;
7451   };
7452 
7453   template <>
7454   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
7455   {
7456     using Type = VULKAN_HPP_NAMESPACE::BufferView;
7457   };
7458 
7459 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7460   template <>
7461   struct CppType<VkBufferView, VK_NULL_HANDLE>
7462   {
7463     using Type = VULKAN_HPP_NAMESPACE::BufferView;
7464   };
7465 #endif
7466 
7467   template <>
7468   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
7469   {
7470     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7471   };
7472 
7473   class CommandPool
7474   {
7475   public:
7476     using CType      = VkCommandPool;
7477     using NativeType = VkCommandPool;
7478 
7479     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
7480     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7481       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
7482 
7483   public:
7484     CommandPool()                                      = default;
7485     CommandPool( CommandPool const & rhs )             = default;
7486     CommandPool & operator=( CommandPool const & rhs ) = default;
7487     CommandPool( CommandPool && rhs )                  = default;
7488     CommandPool & operator=( CommandPool && rhs )      = default;
7489 
CommandPool(std::nullptr_t)7490     VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7491 
CommandPool(VkCommandPool commandPool)7492     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}
7493 
7494 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCommandPool commandPool)7495     CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
7496     {
7497       m_commandPool = commandPool;
7498       return *this;
7499     }
7500 #endif
7501 
operator =(std::nullptr_t)7502     CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7503     {
7504       m_commandPool = {};
7505       return *this;
7506     }
7507 
7508 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7509     auto operator<=>( CommandPool const & ) const = default;
7510 #else
operator ==(CommandPool const & rhs) const7511     bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7512     {
7513       return m_commandPool == rhs.m_commandPool;
7514     }
7515 
operator !=(CommandPool const & rhs) const7516     bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7517     {
7518       return m_commandPool != rhs.m_commandPool;
7519     }
7520 
operator <(CommandPool const & rhs) const7521     bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7522     {
7523       return m_commandPool < rhs.m_commandPool;
7524     }
7525 #endif
7526 
operator VkCommandPool() const7527     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
7528     {
7529       return m_commandPool;
7530     }
7531 
operator bool() const7532     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7533     {
7534       return m_commandPool != VK_NULL_HANDLE;
7535     }
7536 
operator !() const7537     bool operator!() const VULKAN_HPP_NOEXCEPT
7538     {
7539       return m_commandPool == VK_NULL_HANDLE;
7540     }
7541 
7542   private:
7543     VkCommandPool m_commandPool = {};
7544   };
7545 
7546   template <>
7547   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
7548   {
7549     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
7550   };
7551 
7552   template <>
7553   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
7554   {
7555     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
7556   };
7557 
7558 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7559   template <>
7560   struct CppType<VkCommandPool, VK_NULL_HANDLE>
7561   {
7562     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
7563   };
7564 #endif
7565 
7566   template <>
7567   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
7568   {
7569     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7570   };
7571 
7572   class PipelineCache
7573   {
7574   public:
7575     using CType      = VkPipelineCache;
7576     using NativeType = VkPipelineCache;
7577 
7578     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
7579     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7580       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
7581 
7582   public:
7583     PipelineCache()                                        = default;
7584     PipelineCache( PipelineCache const & rhs )             = default;
7585     PipelineCache & operator=( PipelineCache const & rhs ) = default;
7586     PipelineCache( PipelineCache && rhs )                  = default;
7587     PipelineCache & operator=( PipelineCache && rhs )      = default;
7588 
PipelineCache(std::nullptr_t)7589     VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7590 
PipelineCache(VkPipelineCache pipelineCache)7591     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}
7592 
7593 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPipelineCache pipelineCache)7594     PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
7595     {
7596       m_pipelineCache = pipelineCache;
7597       return *this;
7598     }
7599 #endif
7600 
operator =(std::nullptr_t)7601     PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7602     {
7603       m_pipelineCache = {};
7604       return *this;
7605     }
7606 
7607 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7608     auto operator<=>( PipelineCache const & ) const = default;
7609 #else
operator ==(PipelineCache const & rhs) const7610     bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7611     {
7612       return m_pipelineCache == rhs.m_pipelineCache;
7613     }
7614 
operator !=(PipelineCache const & rhs) const7615     bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7616     {
7617       return m_pipelineCache != rhs.m_pipelineCache;
7618     }
7619 
operator <(PipelineCache const & rhs) const7620     bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7621     {
7622       return m_pipelineCache < rhs.m_pipelineCache;
7623     }
7624 #endif
7625 
operator VkPipelineCache() const7626     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
7627     {
7628       return m_pipelineCache;
7629     }
7630 
operator bool() const7631     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7632     {
7633       return m_pipelineCache != VK_NULL_HANDLE;
7634     }
7635 
operator !() const7636     bool operator!() const VULKAN_HPP_NOEXCEPT
7637     {
7638       return m_pipelineCache == VK_NULL_HANDLE;
7639     }
7640 
7641   private:
7642     VkPipelineCache m_pipelineCache = {};
7643   };
7644 
7645   template <>
7646   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
7647   {
7648     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
7649   };
7650 
7651   template <>
7652   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
7653   {
7654     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
7655   };
7656 
7657 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7658   template <>
7659   struct CppType<VkPipelineCache, VK_NULL_HANDLE>
7660   {
7661     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
7662   };
7663 #endif
7664 
7665   template <>
7666   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
7667   {
7668     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7669   };
7670 
7671   class CuFunctionNVX
7672   {
7673   public:
7674     using CType      = VkCuFunctionNVX;
7675     using NativeType = VkCuFunctionNVX;
7676 
7677     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
7678     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7679       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
7680 
7681   public:
7682     CuFunctionNVX()                                        = default;
7683     CuFunctionNVX( CuFunctionNVX const & rhs )             = default;
7684     CuFunctionNVX & operator=( CuFunctionNVX const & rhs ) = default;
7685     CuFunctionNVX( CuFunctionNVX && rhs )                  = default;
7686     CuFunctionNVX & operator=( CuFunctionNVX && rhs )      = default;
7687 
CuFunctionNVX(std::nullptr_t)7688     VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7689 
CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX)7690     VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}
7691 
7692 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCuFunctionNVX cuFunctionNVX)7693     CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
7694     {
7695       m_cuFunctionNVX = cuFunctionNVX;
7696       return *this;
7697     }
7698 #endif
7699 
operator =(std::nullptr_t)7700     CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7701     {
7702       m_cuFunctionNVX = {};
7703       return *this;
7704     }
7705 
7706 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7707     auto operator<=>( CuFunctionNVX const & ) const = default;
7708 #else
operator ==(CuFunctionNVX const & rhs) const7709     bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7710     {
7711       return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
7712     }
7713 
operator !=(CuFunctionNVX const & rhs) const7714     bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7715     {
7716       return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
7717     }
7718 
operator <(CuFunctionNVX const & rhs) const7719     bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7720     {
7721       return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
7722     }
7723 #endif
7724 
operator VkCuFunctionNVX() const7725     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
7726     {
7727       return m_cuFunctionNVX;
7728     }
7729 
operator bool() const7730     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7731     {
7732       return m_cuFunctionNVX != VK_NULL_HANDLE;
7733     }
7734 
operator !() const7735     bool operator!() const VULKAN_HPP_NOEXCEPT
7736     {
7737       return m_cuFunctionNVX == VK_NULL_HANDLE;
7738     }
7739 
7740   private:
7741     VkCuFunctionNVX m_cuFunctionNVX = {};
7742   };
7743 
7744   template <>
7745   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
7746   {
7747     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
7748   };
7749 
7750   template <>
7751   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
7752   {
7753     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
7754   };
7755 
7756 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7757   template <>
7758   struct CppType<VkCuFunctionNVX, VK_NULL_HANDLE>
7759   {
7760     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
7761   };
7762 #endif
7763 
7764   template <>
7765   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
7766   {
7767     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7768   };
7769 
7770   class CuModuleNVX
7771   {
7772   public:
7773     using CType      = VkCuModuleNVX;
7774     using NativeType = VkCuModuleNVX;
7775 
7776     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
7777     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7778       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
7779 
7780   public:
7781     CuModuleNVX()                                      = default;
7782     CuModuleNVX( CuModuleNVX const & rhs )             = default;
7783     CuModuleNVX & operator=( CuModuleNVX const & rhs ) = default;
7784     CuModuleNVX( CuModuleNVX && rhs )                  = default;
7785     CuModuleNVX & operator=( CuModuleNVX && rhs )      = default;
7786 
CuModuleNVX(std::nullptr_t)7787     VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7788 
CuModuleNVX(VkCuModuleNVX cuModuleNVX)7789     VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}
7790 
7791 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCuModuleNVX cuModuleNVX)7792     CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
7793     {
7794       m_cuModuleNVX = cuModuleNVX;
7795       return *this;
7796     }
7797 #endif
7798 
operator =(std::nullptr_t)7799     CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7800     {
7801       m_cuModuleNVX = {};
7802       return *this;
7803     }
7804 
7805 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7806     auto operator<=>( CuModuleNVX const & ) const = default;
7807 #else
operator ==(CuModuleNVX const & rhs) const7808     bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7809     {
7810       return m_cuModuleNVX == rhs.m_cuModuleNVX;
7811     }
7812 
operator !=(CuModuleNVX const & rhs) const7813     bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7814     {
7815       return m_cuModuleNVX != rhs.m_cuModuleNVX;
7816     }
7817 
operator <(CuModuleNVX const & rhs) const7818     bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7819     {
7820       return m_cuModuleNVX < rhs.m_cuModuleNVX;
7821     }
7822 #endif
7823 
operator VkCuModuleNVX() const7824     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
7825     {
7826       return m_cuModuleNVX;
7827     }
7828 
operator bool() const7829     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7830     {
7831       return m_cuModuleNVX != VK_NULL_HANDLE;
7832     }
7833 
operator !() const7834     bool operator!() const VULKAN_HPP_NOEXCEPT
7835     {
7836       return m_cuModuleNVX == VK_NULL_HANDLE;
7837     }
7838 
7839   private:
7840     VkCuModuleNVX m_cuModuleNVX = {};
7841   };
7842 
7843   template <>
7844   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
7845   {
7846     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
7847   };
7848 
7849   template <>
7850   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
7851   {
7852     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
7853   };
7854 
7855 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7856   template <>
7857   struct CppType<VkCuModuleNVX, VK_NULL_HANDLE>
7858   {
7859     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
7860   };
7861 #endif
7862 
7863   template <>
7864   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
7865   {
7866     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7867   };
7868 
7869 #if defined( VK_ENABLE_BETA_EXTENSIONS )
7870   class CudaFunctionNV
7871   {
7872   public:
7873     using CType      = VkCudaFunctionNV;
7874     using NativeType = VkCudaFunctionNV;
7875 
7876     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV;
7877     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7878       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV;
7879 
7880   public:
7881     CudaFunctionNV()                                         = default;
7882     CudaFunctionNV( CudaFunctionNV const & rhs )             = default;
7883     CudaFunctionNV & operator=( CudaFunctionNV const & rhs ) = default;
7884     CudaFunctionNV( CudaFunctionNV && rhs )                  = default;
7885     CudaFunctionNV & operator=( CudaFunctionNV && rhs )      = default;
7886 
CudaFunctionNV(std::nullptr_t)7887     VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7888 
CudaFunctionNV(VkCudaFunctionNV cudaFunctionNV)7889     VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {}
7890 
7891 #  if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCudaFunctionNV cudaFunctionNV)7892     CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT
7893     {
7894       m_cudaFunctionNV = cudaFunctionNV;
7895       return *this;
7896     }
7897 #  endif
7898 
operator =(std::nullptr_t)7899     CudaFunctionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7900     {
7901       m_cudaFunctionNV = {};
7902       return *this;
7903     }
7904 
7905 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7906     auto operator<=>( CudaFunctionNV const & ) const = default;
7907 #  else
operator ==(CudaFunctionNV const & rhs) const7908     bool operator==( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7909     {
7910       return m_cudaFunctionNV == rhs.m_cudaFunctionNV;
7911     }
7912 
operator !=(CudaFunctionNV const & rhs) const7913     bool operator!=( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7914     {
7915       return m_cudaFunctionNV != rhs.m_cudaFunctionNV;
7916     }
7917 
operator <(CudaFunctionNV const & rhs) const7918     bool operator<( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7919     {
7920       return m_cudaFunctionNV < rhs.m_cudaFunctionNV;
7921     }
7922 #  endif
7923 
operator VkCudaFunctionNV() const7924     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT
7925     {
7926       return m_cudaFunctionNV;
7927     }
7928 
operator bool() const7929     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7930     {
7931       return m_cudaFunctionNV != VK_NULL_HANDLE;
7932     }
7933 
operator !() const7934     bool operator!() const VULKAN_HPP_NOEXCEPT
7935     {
7936       return m_cudaFunctionNV == VK_NULL_HANDLE;
7937     }
7938 
7939   private:
7940     VkCudaFunctionNV m_cudaFunctionNV = {};
7941   };
7942 
7943   template <>
7944   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV>
7945   {
7946     using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
7947   };
7948 
7949   template <>
7950   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV>
7951   {
7952     using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
7953   };
7954 
7955 #  if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7956   template <>
7957   struct CppType<VkCudaFunctionNV, VK_NULL_HANDLE>
7958   {
7959     using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
7960   };
7961 #  endif
7962 
7963   template <>
7964   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>
7965   {
7966     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7967   };
7968 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
7969 
7970 #if defined( VK_ENABLE_BETA_EXTENSIONS )
7971   class CudaModuleNV
7972   {
7973   public:
7974     using CType      = VkCudaModuleNV;
7975     using NativeType = VkCudaModuleNV;
7976 
7977     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV;
7978     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7979       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV;
7980 
7981   public:
7982     CudaModuleNV()                                       = default;
7983     CudaModuleNV( CudaModuleNV const & rhs )             = default;
7984     CudaModuleNV & operator=( CudaModuleNV const & rhs ) = default;
7985     CudaModuleNV( CudaModuleNV && rhs )                  = default;
7986     CudaModuleNV & operator=( CudaModuleNV && rhs )      = default;
7987 
CudaModuleNV(std::nullptr_t)7988     VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7989 
CudaModuleNV(VkCudaModuleNV cudaModuleNV)7990     VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {}
7991 
7992 #  if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCudaModuleNV cudaModuleNV)7993     CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT
7994     {
7995       m_cudaModuleNV = cudaModuleNV;
7996       return *this;
7997     }
7998 #  endif
7999 
operator =(std::nullptr_t)8000     CudaModuleNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8001     {
8002       m_cudaModuleNV = {};
8003       return *this;
8004     }
8005 
8006 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8007     auto operator<=>( CudaModuleNV const & ) const = default;
8008 #  else
operator ==(CudaModuleNV const & rhs) const8009     bool operator==( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8010     {
8011       return m_cudaModuleNV == rhs.m_cudaModuleNV;
8012     }
8013 
operator !=(CudaModuleNV const & rhs) const8014     bool operator!=( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8015     {
8016       return m_cudaModuleNV != rhs.m_cudaModuleNV;
8017     }
8018 
operator <(CudaModuleNV const & rhs) const8019     bool operator<( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8020     {
8021       return m_cudaModuleNV < rhs.m_cudaModuleNV;
8022     }
8023 #  endif
8024 
operator VkCudaModuleNV() const8025     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT
8026     {
8027       return m_cudaModuleNV;
8028     }
8029 
operator bool() const8030     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8031     {
8032       return m_cudaModuleNV != VK_NULL_HANDLE;
8033     }
8034 
operator !() const8035     bool operator!() const VULKAN_HPP_NOEXCEPT
8036     {
8037       return m_cudaModuleNV == VK_NULL_HANDLE;
8038     }
8039 
8040   private:
8041     VkCudaModuleNV m_cudaModuleNV = {};
8042   };
8043 
8044   template <>
8045   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV>
8046   {
8047     using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
8048   };
8049 
8050   template <>
8051   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV>
8052   {
8053     using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
8054   };
8055 
8056 #  if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8057   template <>
8058   struct CppType<VkCudaModuleNV, VK_NULL_HANDLE>
8059   {
8060     using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
8061   };
8062 #  endif
8063 
8064   template <>
8065   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaModuleNV>
8066   {
8067     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8068   };
8069 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
8070 
8071   class DescriptorPool
8072   {
8073   public:
8074     using CType      = VkDescriptorPool;
8075     using NativeType = VkDescriptorPool;
8076 
8077     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
8078     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8079       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
8080 
8081   public:
8082     DescriptorPool()                                         = default;
8083     DescriptorPool( DescriptorPool const & rhs )             = default;
8084     DescriptorPool & operator=( DescriptorPool const & rhs ) = default;
8085     DescriptorPool( DescriptorPool && rhs )                  = default;
8086     DescriptorPool & operator=( DescriptorPool && rhs )      = default;
8087 
DescriptorPool(std::nullptr_t)8088     VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8089 
DescriptorPool(VkDescriptorPool descriptorPool)8090     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}
8091 
8092 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDescriptorPool descriptorPool)8093     DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
8094     {
8095       m_descriptorPool = descriptorPool;
8096       return *this;
8097     }
8098 #endif
8099 
operator =(std::nullptr_t)8100     DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8101     {
8102       m_descriptorPool = {};
8103       return *this;
8104     }
8105 
8106 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8107     auto operator<=>( DescriptorPool const & ) const = default;
8108 #else
operator ==(DescriptorPool const & rhs) const8109     bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
8110     {
8111       return m_descriptorPool == rhs.m_descriptorPool;
8112     }
8113 
operator !=(DescriptorPool const & rhs) const8114     bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
8115     {
8116       return m_descriptorPool != rhs.m_descriptorPool;
8117     }
8118 
operator <(DescriptorPool const & rhs) const8119     bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
8120     {
8121       return m_descriptorPool < rhs.m_descriptorPool;
8122     }
8123 #endif
8124 
operator VkDescriptorPool() const8125     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
8126     {
8127       return m_descriptorPool;
8128     }
8129 
operator bool() const8130     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8131     {
8132       return m_descriptorPool != VK_NULL_HANDLE;
8133     }
8134 
operator !() const8135     bool operator!() const VULKAN_HPP_NOEXCEPT
8136     {
8137       return m_descriptorPool == VK_NULL_HANDLE;
8138     }
8139 
8140   private:
8141     VkDescriptorPool m_descriptorPool = {};
8142   };
8143 
8144   template <>
8145   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
8146   {
8147     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
8148   };
8149 
8150   template <>
8151   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
8152   {
8153     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
8154   };
8155 
8156 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8157   template <>
8158   struct CppType<VkDescriptorPool, VK_NULL_HANDLE>
8159   {
8160     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
8161   };
8162 #endif
8163 
8164   template <>
8165   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
8166   {
8167     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8168   };
8169 
8170   class DescriptorSetLayout
8171   {
8172   public:
8173     using CType      = VkDescriptorSetLayout;
8174     using NativeType = VkDescriptorSetLayout;
8175 
8176     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
8177     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8178       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
8179 
8180   public:
8181     DescriptorSetLayout()                                              = default;
8182     DescriptorSetLayout( DescriptorSetLayout const & rhs )             = default;
8183     DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default;
8184     DescriptorSetLayout( DescriptorSetLayout && rhs )                  = default;
8185     DescriptorSetLayout & operator=( DescriptorSetLayout && rhs )      = default;
8186 
DescriptorSetLayout(std::nullptr_t)8187     VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8188 
DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)8189     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
8190       : m_descriptorSetLayout( descriptorSetLayout )
8191     {
8192     }
8193 
8194 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDescriptorSetLayout descriptorSetLayout)8195     DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
8196     {
8197       m_descriptorSetLayout = descriptorSetLayout;
8198       return *this;
8199     }
8200 #endif
8201 
operator =(std::nullptr_t)8202     DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8203     {
8204       m_descriptorSetLayout = {};
8205       return *this;
8206     }
8207 
8208 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8209     auto operator<=>( DescriptorSetLayout const & ) const = default;
8210 #else
operator ==(DescriptorSetLayout const & rhs) const8211     bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
8212     {
8213       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
8214     }
8215 
operator !=(DescriptorSetLayout const & rhs) const8216     bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
8217     {
8218       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
8219     }
8220 
operator <(DescriptorSetLayout const & rhs) const8221     bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
8222     {
8223       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
8224     }
8225 #endif
8226 
operator VkDescriptorSetLayout() const8227     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
8228     {
8229       return m_descriptorSetLayout;
8230     }
8231 
operator bool() const8232     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8233     {
8234       return m_descriptorSetLayout != VK_NULL_HANDLE;
8235     }
8236 
operator !() const8237     bool operator!() const VULKAN_HPP_NOEXCEPT
8238     {
8239       return m_descriptorSetLayout == VK_NULL_HANDLE;
8240     }
8241 
8242   private:
8243     VkDescriptorSetLayout m_descriptorSetLayout = {};
8244   };
8245 
8246   template <>
8247   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
8248   {
8249     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
8250   };
8251 
8252   template <>
8253   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
8254   {
8255     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
8256   };
8257 
8258 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8259   template <>
8260   struct CppType<VkDescriptorSetLayout, VK_NULL_HANDLE>
8261   {
8262     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
8263   };
8264 #endif
8265 
8266   template <>
8267   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
8268   {
8269     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8270   };
8271 
8272   class Framebuffer
8273   {
8274   public:
8275     using CType      = VkFramebuffer;
8276     using NativeType = VkFramebuffer;
8277 
8278     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
8279     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8280       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
8281 
8282   public:
8283     Framebuffer()                                      = default;
8284     Framebuffer( Framebuffer const & rhs )             = default;
8285     Framebuffer & operator=( Framebuffer const & rhs ) = default;
8286     Framebuffer( Framebuffer && rhs )                  = default;
8287     Framebuffer & operator=( Framebuffer && rhs )      = default;
8288 
Framebuffer(std::nullptr_t)8289     VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8290 
Framebuffer(VkFramebuffer framebuffer)8291     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {}
8292 
8293 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkFramebuffer framebuffer)8294     Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
8295     {
8296       m_framebuffer = framebuffer;
8297       return *this;
8298     }
8299 #endif
8300 
operator =(std::nullptr_t)8301     Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8302     {
8303       m_framebuffer = {};
8304       return *this;
8305     }
8306 
8307 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8308     auto operator<=>( Framebuffer const & ) const = default;
8309 #else
operator ==(Framebuffer const & rhs) const8310     bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
8311     {
8312       return m_framebuffer == rhs.m_framebuffer;
8313     }
8314 
operator !=(Framebuffer const & rhs) const8315     bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
8316     {
8317       return m_framebuffer != rhs.m_framebuffer;
8318     }
8319 
operator <(Framebuffer const & rhs) const8320     bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
8321     {
8322       return m_framebuffer < rhs.m_framebuffer;
8323     }
8324 #endif
8325 
operator VkFramebuffer() const8326     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
8327     {
8328       return m_framebuffer;
8329     }
8330 
operator bool() const8331     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8332     {
8333       return m_framebuffer != VK_NULL_HANDLE;
8334     }
8335 
operator !() const8336     bool operator!() const VULKAN_HPP_NOEXCEPT
8337     {
8338       return m_framebuffer == VK_NULL_HANDLE;
8339     }
8340 
8341   private:
8342     VkFramebuffer m_framebuffer = {};
8343   };
8344 
8345   template <>
8346   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
8347   {
8348     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
8349   };
8350 
8351   template <>
8352   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
8353   {
8354     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
8355   };
8356 
8357 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8358   template <>
8359   struct CppType<VkFramebuffer, VK_NULL_HANDLE>
8360   {
8361     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
8362   };
8363 #endif
8364 
8365   template <>
8366   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
8367   {
8368     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8369   };
8370 
8371   class IndirectCommandsLayoutNV
8372   {
8373   public:
8374     using CType      = VkIndirectCommandsLayoutNV;
8375     using NativeType = VkIndirectCommandsLayoutNV;
8376 
8377     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
8378     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8379       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
8380 
8381   public:
8382     IndirectCommandsLayoutNV()                                                   = default;
8383     IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & rhs )             = default;
8384     IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & rhs ) = default;
8385     IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs )                  = default;
8386     IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs )      = default;
8387 
IndirectCommandsLayoutNV(std::nullptr_t)8388     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8389 
IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)8390     VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
8391       : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
8392     {
8393     }
8394 
8395 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)8396     IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
8397     {
8398       m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
8399       return *this;
8400     }
8401 #endif
8402 
operator =(std::nullptr_t)8403     IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8404     {
8405       m_indirectCommandsLayoutNV = {};
8406       return *this;
8407     }
8408 
8409 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8410     auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
8411 #else
operator ==(IndirectCommandsLayoutNV const & rhs) const8412     bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8413     {
8414       return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
8415     }
8416 
operator !=(IndirectCommandsLayoutNV const & rhs) const8417     bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8418     {
8419       return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
8420     }
8421 
operator <(IndirectCommandsLayoutNV const & rhs) const8422     bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8423     {
8424       return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
8425     }
8426 #endif
8427 
operator VkIndirectCommandsLayoutNV() const8428     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
8429     {
8430       return m_indirectCommandsLayoutNV;
8431     }
8432 
operator bool() const8433     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8434     {
8435       return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
8436     }
8437 
operator !() const8438     bool operator!() const VULKAN_HPP_NOEXCEPT
8439     {
8440       return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
8441     }
8442 
8443   private:
8444     VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
8445   };
8446 
8447   template <>
8448   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
8449   {
8450     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
8451   };
8452 
8453 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8454   template <>
8455   struct CppType<VkIndirectCommandsLayoutNV, VK_NULL_HANDLE>
8456   {
8457     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
8458   };
8459 #endif
8460 
8461   template <>
8462   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
8463   {
8464     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8465   };
8466 
8467   class PrivateDataSlot
8468   {
8469   public:
8470     using CType      = VkPrivateDataSlot;
8471     using NativeType = VkPrivateDataSlot;
8472 
8473     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;
8474     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8475       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
8476 
8477   public:
8478     PrivateDataSlot()                                          = default;
8479     PrivateDataSlot( PrivateDataSlot const & rhs )             = default;
8480     PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default;
8481     PrivateDataSlot( PrivateDataSlot && rhs )                  = default;
8482     PrivateDataSlot & operator=( PrivateDataSlot && rhs )      = default;
8483 
PrivateDataSlot(std::nullptr_t)8484     VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8485 
PrivateDataSlot(VkPrivateDataSlot privateDataSlot)8486     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}
8487 
8488 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPrivateDataSlot privateDataSlot)8489     PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
8490     {
8491       m_privateDataSlot = privateDataSlot;
8492       return *this;
8493     }
8494 #endif
8495 
operator =(std::nullptr_t)8496     PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8497     {
8498       m_privateDataSlot = {};
8499       return *this;
8500     }
8501 
8502 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8503     auto operator<=>( PrivateDataSlot const & ) const = default;
8504 #else
operator ==(PrivateDataSlot const & rhs) const8505     bool operator==( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
8506     {
8507       return m_privateDataSlot == rhs.m_privateDataSlot;
8508     }
8509 
operator !=(PrivateDataSlot const & rhs) const8510     bool operator!=( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
8511     {
8512       return m_privateDataSlot != rhs.m_privateDataSlot;
8513     }
8514 
operator <(PrivateDataSlot const & rhs) const8515     bool operator<( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
8516     {
8517       return m_privateDataSlot < rhs.m_privateDataSlot;
8518     }
8519 #endif
8520 
operator VkPrivateDataSlot() const8521     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
8522     {
8523       return m_privateDataSlot;
8524     }
8525 
operator bool() const8526     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8527     {
8528       return m_privateDataSlot != VK_NULL_HANDLE;
8529     }
8530 
operator !() const8531     bool operator!() const VULKAN_HPP_NOEXCEPT
8532     {
8533       return m_privateDataSlot == VK_NULL_HANDLE;
8534     }
8535 
8536   private:
8537     VkPrivateDataSlot m_privateDataSlot = {};
8538   };
8539 
8540   template <>
8541   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>
8542   {
8543     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;
8544   };
8545 
8546 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8547   template <>
8548   struct CppType<VkPrivateDataSlot, VK_NULL_HANDLE>
8549   {
8550     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;
8551   };
8552 #endif
8553 
8554   template <>
8555   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
8556   {
8557     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8558   };
8559 
8560   using PrivateDataSlotEXT = PrivateDataSlot;
8561 
8562   class RenderPass
8563   {
8564   public:
8565     using CType      = VkRenderPass;
8566     using NativeType = VkRenderPass;
8567 
8568     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
8569     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8570       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
8571 
8572   public:
8573     RenderPass()                                     = default;
8574     RenderPass( RenderPass const & rhs )             = default;
8575     RenderPass & operator=( RenderPass const & rhs ) = default;
8576     RenderPass( RenderPass && rhs )                  = default;
8577     RenderPass & operator=( RenderPass && rhs )      = default;
8578 
RenderPass(std::nullptr_t)8579     VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8580 
RenderPass(VkRenderPass renderPass)8581     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}
8582 
8583 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkRenderPass renderPass)8584     RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
8585     {
8586       m_renderPass = renderPass;
8587       return *this;
8588     }
8589 #endif
8590 
operator =(std::nullptr_t)8591     RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8592     {
8593       m_renderPass = {};
8594       return *this;
8595     }
8596 
8597 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8598     auto operator<=>( RenderPass const & ) const = default;
8599 #else
operator ==(RenderPass const & rhs) const8600     bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8601     {
8602       return m_renderPass == rhs.m_renderPass;
8603     }
8604 
operator !=(RenderPass const & rhs) const8605     bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8606     {
8607       return m_renderPass != rhs.m_renderPass;
8608     }
8609 
operator <(RenderPass const & rhs) const8610     bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8611     {
8612       return m_renderPass < rhs.m_renderPass;
8613     }
8614 #endif
8615 
operator VkRenderPass() const8616     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
8617     {
8618       return m_renderPass;
8619     }
8620 
operator bool() const8621     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8622     {
8623       return m_renderPass != VK_NULL_HANDLE;
8624     }
8625 
operator !() const8626     bool operator!() const VULKAN_HPP_NOEXCEPT
8627     {
8628       return m_renderPass == VK_NULL_HANDLE;
8629     }
8630 
8631   private:
8632     VkRenderPass m_renderPass = {};
8633   };
8634 
8635   template <>
8636   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
8637   {
8638     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
8639   };
8640 
8641   template <>
8642   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
8643   {
8644     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
8645   };
8646 
8647 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8648   template <>
8649   struct CppType<VkRenderPass, VK_NULL_HANDLE>
8650   {
8651     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
8652   };
8653 #endif
8654 
8655   template <>
8656   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
8657   {
8658     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8659   };
8660 
8661   class Sampler
8662   {
8663   public:
8664     using CType      = VkSampler;
8665     using NativeType = VkSampler;
8666 
8667     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
8668     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8669       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
8670 
8671   public:
8672     Sampler()                                  = default;
8673     Sampler( Sampler const & rhs )             = default;
8674     Sampler & operator=( Sampler const & rhs ) = default;
8675     Sampler( Sampler && rhs )                  = default;
8676     Sampler & operator=( Sampler && rhs )      = default;
8677 
Sampler(std::nullptr_t)8678     VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8679 
Sampler(VkSampler sampler)8680     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
8681 
8682 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSampler sampler)8683     Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
8684     {
8685       m_sampler = sampler;
8686       return *this;
8687     }
8688 #endif
8689 
operator =(std::nullptr_t)8690     Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8691     {
8692       m_sampler = {};
8693       return *this;
8694     }
8695 
8696 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8697     auto operator<=>( Sampler const & ) const = default;
8698 #else
operator ==(Sampler const & rhs) const8699     bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8700     {
8701       return m_sampler == rhs.m_sampler;
8702     }
8703 
operator !=(Sampler const & rhs) const8704     bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8705     {
8706       return m_sampler != rhs.m_sampler;
8707     }
8708 
operator <(Sampler const & rhs) const8709     bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8710     {
8711       return m_sampler < rhs.m_sampler;
8712     }
8713 #endif
8714 
operator VkSampler() const8715     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
8716     {
8717       return m_sampler;
8718     }
8719 
operator bool() const8720     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8721     {
8722       return m_sampler != VK_NULL_HANDLE;
8723     }
8724 
operator !() const8725     bool operator!() const VULKAN_HPP_NOEXCEPT
8726     {
8727       return m_sampler == VK_NULL_HANDLE;
8728     }
8729 
8730   private:
8731     VkSampler m_sampler = {};
8732   };
8733 
8734   template <>
8735   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
8736   {
8737     using Type = VULKAN_HPP_NAMESPACE::Sampler;
8738   };
8739 
8740   template <>
8741   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
8742   {
8743     using Type = VULKAN_HPP_NAMESPACE::Sampler;
8744   };
8745 
8746 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8747   template <>
8748   struct CppType<VkSampler, VK_NULL_HANDLE>
8749   {
8750     using Type = VULKAN_HPP_NAMESPACE::Sampler;
8751   };
8752 #endif
8753 
8754   template <>
8755   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
8756   {
8757     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8758   };
8759 
8760   class SamplerYcbcrConversion
8761   {
8762   public:
8763     using CType      = VkSamplerYcbcrConversion;
8764     using NativeType = VkSamplerYcbcrConversion;
8765 
8766     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
8767     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8768       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
8769 
8770   public:
8771     SamplerYcbcrConversion()                                                 = default;
8772     SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs )             = default;
8773     SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default;
8774     SamplerYcbcrConversion( SamplerYcbcrConversion && rhs )                  = default;
8775     SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs )      = default;
8776 
SamplerYcbcrConversion(std::nullptr_t)8777     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8778 
SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)8779     VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
8780       : m_samplerYcbcrConversion( samplerYcbcrConversion )
8781     {
8782     }
8783 
8784 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSamplerYcbcrConversion samplerYcbcrConversion)8785     SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
8786     {
8787       m_samplerYcbcrConversion = samplerYcbcrConversion;
8788       return *this;
8789     }
8790 #endif
8791 
operator =(std::nullptr_t)8792     SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8793     {
8794       m_samplerYcbcrConversion = {};
8795       return *this;
8796     }
8797 
8798 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8799     auto operator<=>( SamplerYcbcrConversion const & ) const = default;
8800 #else
operator ==(SamplerYcbcrConversion const & rhs) const8801     bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
8802     {
8803       return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
8804     }
8805 
operator !=(SamplerYcbcrConversion const & rhs) const8806     bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
8807     {
8808       return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
8809     }
8810 
operator <(SamplerYcbcrConversion const & rhs) const8811     bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
8812     {
8813       return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
8814     }
8815 #endif
8816 
operator VkSamplerYcbcrConversion() const8817     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
8818     {
8819       return m_samplerYcbcrConversion;
8820     }
8821 
operator bool() const8822     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8823     {
8824       return m_samplerYcbcrConversion != VK_NULL_HANDLE;
8825     }
8826 
operator !() const8827     bool operator!() const VULKAN_HPP_NOEXCEPT
8828     {
8829       return m_samplerYcbcrConversion == VK_NULL_HANDLE;
8830     }
8831 
8832   private:
8833     VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
8834   };
8835 
8836   template <>
8837   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
8838   {
8839     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
8840   };
8841 
8842   template <>
8843   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
8844   {
8845     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
8846   };
8847 
8848 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8849   template <>
8850   struct CppType<VkSamplerYcbcrConversion, VK_NULL_HANDLE>
8851   {
8852     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
8853   };
8854 #endif
8855 
8856   template <>
8857   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
8858   {
8859     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8860   };
8861 
8862   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
8863 
8864   class ShaderModule
8865   {
8866   public:
8867     using CType      = VkShaderModule;
8868     using NativeType = VkShaderModule;
8869 
8870     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
8871     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8872       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
8873 
8874   public:
8875     ShaderModule()                                       = default;
8876     ShaderModule( ShaderModule const & rhs )             = default;
8877     ShaderModule & operator=( ShaderModule const & rhs ) = default;
8878     ShaderModule( ShaderModule && rhs )                  = default;
8879     ShaderModule & operator=( ShaderModule && rhs )      = default;
8880 
ShaderModule(std::nullptr_t)8881     VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8882 
ShaderModule(VkShaderModule shaderModule)8883     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}
8884 
8885 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkShaderModule shaderModule)8886     ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
8887     {
8888       m_shaderModule = shaderModule;
8889       return *this;
8890     }
8891 #endif
8892 
operator =(std::nullptr_t)8893     ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8894     {
8895       m_shaderModule = {};
8896       return *this;
8897     }
8898 
8899 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8900     auto operator<=>( ShaderModule const & ) const = default;
8901 #else
operator ==(ShaderModule const & rhs) const8902     bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8903     {
8904       return m_shaderModule == rhs.m_shaderModule;
8905     }
8906 
operator !=(ShaderModule const & rhs) const8907     bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8908     {
8909       return m_shaderModule != rhs.m_shaderModule;
8910     }
8911 
operator <(ShaderModule const & rhs) const8912     bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8913     {
8914       return m_shaderModule < rhs.m_shaderModule;
8915     }
8916 #endif
8917 
operator VkShaderModule() const8918     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
8919     {
8920       return m_shaderModule;
8921     }
8922 
operator bool() const8923     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8924     {
8925       return m_shaderModule != VK_NULL_HANDLE;
8926     }
8927 
operator !() const8928     bool operator!() const VULKAN_HPP_NOEXCEPT
8929     {
8930       return m_shaderModule == VK_NULL_HANDLE;
8931     }
8932 
8933   private:
8934     VkShaderModule m_shaderModule = {};
8935   };
8936 
8937   template <>
8938   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
8939   {
8940     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
8941   };
8942 
8943   template <>
8944   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
8945   {
8946     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
8947   };
8948 
8949 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8950   template <>
8951   struct CppType<VkShaderModule, VK_NULL_HANDLE>
8952   {
8953     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
8954   };
8955 #endif
8956 
8957   template <>
8958   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
8959   {
8960     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8961   };
8962 
8963   class ValidationCacheEXT
8964   {
8965   public:
8966     using CType      = VkValidationCacheEXT;
8967     using NativeType = VkValidationCacheEXT;
8968 
8969     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
8970     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8971       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
8972 
8973   public:
8974     ValidationCacheEXT()                                             = default;
8975     ValidationCacheEXT( ValidationCacheEXT const & rhs )             = default;
8976     ValidationCacheEXT & operator=( ValidationCacheEXT const & rhs ) = default;
8977     ValidationCacheEXT( ValidationCacheEXT && rhs )                  = default;
8978     ValidationCacheEXT & operator=( ValidationCacheEXT && rhs )      = default;
8979 
ValidationCacheEXT(std::nullptr_t)8980     VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8981 
ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT)8982     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )
8983     {
8984     }
8985 
8986 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkValidationCacheEXT validationCacheEXT)8987     ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
8988     {
8989       m_validationCacheEXT = validationCacheEXT;
8990       return *this;
8991     }
8992 #endif
8993 
operator =(std::nullptr_t)8994     ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8995     {
8996       m_validationCacheEXT = {};
8997       return *this;
8998     }
8999 
9000 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9001     auto operator<=>( ValidationCacheEXT const & ) const = default;
9002 #else
operator ==(ValidationCacheEXT const & rhs) const9003     bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
9004     {
9005       return m_validationCacheEXT == rhs.m_validationCacheEXT;
9006     }
9007 
operator !=(ValidationCacheEXT const & rhs) const9008     bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
9009     {
9010       return m_validationCacheEXT != rhs.m_validationCacheEXT;
9011     }
9012 
operator <(ValidationCacheEXT const & rhs) const9013     bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
9014     {
9015       return m_validationCacheEXT < rhs.m_validationCacheEXT;
9016     }
9017 #endif
9018 
operator VkValidationCacheEXT() const9019     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
9020     {
9021       return m_validationCacheEXT;
9022     }
9023 
operator bool() const9024     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9025     {
9026       return m_validationCacheEXT != VK_NULL_HANDLE;
9027     }
9028 
operator !() const9029     bool operator!() const VULKAN_HPP_NOEXCEPT
9030     {
9031       return m_validationCacheEXT == VK_NULL_HANDLE;
9032     }
9033 
9034   private:
9035     VkValidationCacheEXT m_validationCacheEXT = {};
9036   };
9037 
9038   template <>
9039   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
9040   {
9041     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
9042   };
9043 
9044   template <>
9045   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
9046   {
9047     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
9048   };
9049 
9050 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9051   template <>
9052   struct CppType<VkValidationCacheEXT, VK_NULL_HANDLE>
9053   {
9054     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
9055   };
9056 #endif
9057 
9058   template <>
9059   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
9060   {
9061     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9062   };
9063 
9064   class VideoSessionParametersKHR
9065   {
9066   public:
9067     using CType      = VkVideoSessionParametersKHR;
9068     using NativeType = VkVideoSessionParametersKHR;
9069 
9070     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
9071     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9072       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
9073 
9074   public:
9075     VideoSessionParametersKHR()                                                    = default;
9076     VideoSessionParametersKHR( VideoSessionParametersKHR const & rhs )             = default;
9077     VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & rhs ) = default;
9078     VideoSessionParametersKHR( VideoSessionParametersKHR && rhs )                  = default;
9079     VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs )      = default;
9080 
VideoSessionParametersKHR(std::nullptr_t)9081     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9082 
VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR)9083     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
9084       : m_videoSessionParametersKHR( videoSessionParametersKHR )
9085     {
9086     }
9087 
9088 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkVideoSessionParametersKHR videoSessionParametersKHR)9089     VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
9090     {
9091       m_videoSessionParametersKHR = videoSessionParametersKHR;
9092       return *this;
9093     }
9094 #endif
9095 
operator =(std::nullptr_t)9096     VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9097     {
9098       m_videoSessionParametersKHR = {};
9099       return *this;
9100     }
9101 
9102 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9103     auto operator<=>( VideoSessionParametersKHR const & ) const = default;
9104 #else
operator ==(VideoSessionParametersKHR const & rhs) const9105     bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
9106     {
9107       return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
9108     }
9109 
operator !=(VideoSessionParametersKHR const & rhs) const9110     bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
9111     {
9112       return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
9113     }
9114 
operator <(VideoSessionParametersKHR const & rhs) const9115     bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
9116     {
9117       return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
9118     }
9119 #endif
9120 
operator VkVideoSessionParametersKHR() const9121     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
9122     {
9123       return m_videoSessionParametersKHR;
9124     }
9125 
operator bool() const9126     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9127     {
9128       return m_videoSessionParametersKHR != VK_NULL_HANDLE;
9129     }
9130 
operator !() const9131     bool operator!() const VULKAN_HPP_NOEXCEPT
9132     {
9133       return m_videoSessionParametersKHR == VK_NULL_HANDLE;
9134     }
9135 
9136   private:
9137     VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
9138   };
9139 
9140   template <>
9141   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
9142   {
9143     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
9144   };
9145 
9146 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9147   template <>
9148   struct CppType<VkVideoSessionParametersKHR, VK_NULL_HANDLE>
9149   {
9150     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
9151   };
9152 #endif
9153 
9154   template <>
9155   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
9156   {
9157     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9158   };
9159 
9160   class Queue
9161   {
9162   public:
9163     using CType      = VkQueue;
9164     using NativeType = VkQueue;
9165 
9166     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
9167     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9168       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
9169 
9170   public:
9171     Queue()                                = default;
9172     Queue( Queue const & rhs )             = default;
9173     Queue & operator=( Queue const & rhs ) = default;
9174     Queue( Queue && rhs )                  = default;
9175     Queue & operator=( Queue && rhs )      = default;
9176 
Queue(std::nullptr_t)9177     VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9178 
Queue(VkQueue queue)9179     Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
9180 
operator =(VkQueue queue)9181     Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
9182     {
9183       m_queue = queue;
9184       return *this;
9185     }
9186 
operator =(std::nullptr_t)9187     Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9188     {
9189       m_queue = {};
9190       return *this;
9191     }
9192 
9193 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9194     auto operator<=>( Queue const & ) const = default;
9195 #else
operator ==(Queue const & rhs) const9196     bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
9197     {
9198       return m_queue == rhs.m_queue;
9199     }
9200 
operator !=(Queue const & rhs) const9201     bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
9202     {
9203       return m_queue != rhs.m_queue;
9204     }
9205 
operator <(Queue const & rhs) const9206     bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
9207     {
9208       return m_queue < rhs.m_queue;
9209     }
9210 #endif
9211 
9212     //=== VK_VERSION_1_0 ===
9213 
9214     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9215     VULKAN_HPP_NODISCARD Result submit( uint32_t                                 submitCount,
9216                                         const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
9217                                         VULKAN_HPP_NAMESPACE::Fence              fence,
9218                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9219 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9220     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9221     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9222       submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
9223               VULKAN_HPP_NAMESPACE::Fence fence                                                VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9224               Dispatch const & d                                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9226 
9227 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9228     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9229     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9230 #else
9231     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9232     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9233 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9234 
9235     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9236     VULKAN_HPP_NODISCARD Result bindSparse( uint32_t                                     bindInfoCount,
9237                                             const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
9238                                             VULKAN_HPP_NAMESPACE::Fence                  fence,
9239                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9240 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9241     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9242     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9243       bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
9244                   VULKAN_HPP_NAMESPACE::Fence fence                                                    VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9245                   Dispatch const & d                                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9246 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9247 
9248     //=== VK_VERSION_1_3 ===
9249 
9250     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9251     VULKAN_HPP_NODISCARD Result submit2( uint32_t                                  submitCount,
9252                                          const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
9253                                          VULKAN_HPP_NAMESPACE::Fence               fence,
9254                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9256     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9257     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9258       submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
9259                VULKAN_HPP_NAMESPACE::Fence fence                                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9260                Dispatch const & d                                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9261 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9262 
9263     //=== VK_KHR_swapchain ===
9264 
9265     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9266     VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
9267                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9269     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9270     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo,
9271                                                                   Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9272 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9273 
9274     //=== VK_EXT_debug_utils ===
9275 
9276     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9277     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
9278                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9279 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9280     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9281     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
9282                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9283 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9284 
9285     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9286     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9287 
9288     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9289     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
9290                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9291 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9292     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9293     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
9294                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9295 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9296 
9297     //=== VK_NV_device_diagnostic_checkpoints ===
9298 
9299     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9300     void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
9301                               VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
9302                               Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9303 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9304     template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
9305               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9306     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
9307                          getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9308     template <
9309       typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
9310       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9311       typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type = 0>
9312     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
9313       getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9314 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9315 
9316     //=== VK_INTEL_performance_query ===
9317 
9318 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9319     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9320     VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
9321                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9322 #else
9323     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9324     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9325          setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
9326                                            Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9327 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9328 
9329     //=== VK_KHR_synchronization2 ===
9330 
9331     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9332     VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t                                  submitCount,
9333                                             const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
9334                                             VULKAN_HPP_NAMESPACE::Fence               fence,
9335                                             Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9336 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9337     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9338     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9339       submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
9340                   VULKAN_HPP_NAMESPACE::Fence fence                                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9341                   Dispatch const & d                                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9342 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9343 
9344     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9345     void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
9346                                VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
9347                                Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9348 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9349     template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
9350               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9351     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
9352                          getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9353     template <
9354       typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
9355       typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9356       typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type = 0>
9357     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
9358       getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9359 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9360 
9361     //=== VK_NV_low_latency2 ===
9362 
9363     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9364     void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo,
9365                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9368     void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo,
9369                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9370 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9371 
operator VkQueue() const9372     operator VkQueue() const VULKAN_HPP_NOEXCEPT
9373     {
9374       return m_queue;
9375     }
9376 
operator bool() const9377     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9378     {
9379       return m_queue != VK_NULL_HANDLE;
9380     }
9381 
operator !() const9382     bool operator!() const VULKAN_HPP_NOEXCEPT
9383     {
9384       return m_queue == VK_NULL_HANDLE;
9385     }
9386 
9387   private:
9388     VkQueue m_queue = {};
9389   };
9390 
9391   template <>
9392   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
9393   {
9394     using Type = VULKAN_HPP_NAMESPACE::Queue;
9395   };
9396 
9397   template <>
9398   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
9399   {
9400     using Type = VULKAN_HPP_NAMESPACE::Queue;
9401   };
9402 
9403 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9404   template <>
9405   struct CppType<VkQueue, VK_NULL_HANDLE>
9406   {
9407     using Type = VULKAN_HPP_NAMESPACE::Queue;
9408   };
9409 #endif
9410 
9411   template <>
9412   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
9413   {
9414     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9415   };
9416 
9417   class Device
9418   {
9419   public:
9420     using CType      = VkDevice;
9421     using NativeType = VkDevice;
9422 
9423     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
9424     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9425       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
9426 
9427   public:
9428     Device()                                 = default;
9429     Device( Device const & rhs )             = default;
9430     Device & operator=( Device const & rhs ) = default;
9431     Device( Device && rhs )                  = default;
9432     Device & operator=( Device && rhs )      = default;
9433 
Device(std::nullptr_t)9434     VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9435 
Device(VkDevice device)9436     Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
9437 
operator =(VkDevice device)9438     Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
9439     {
9440       m_device = device;
9441       return *this;
9442     }
9443 
operator =(std::nullptr_t)9444     Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9445     {
9446       m_device = {};
9447       return *this;
9448     }
9449 
9450 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9451     auto operator<=>( Device const & ) const = default;
9452 #else
operator ==(Device const & rhs) const9453     bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
9454     {
9455       return m_device == rhs.m_device;
9456     }
9457 
operator !=(Device const & rhs) const9458     bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
9459     {
9460       return m_device != rhs.m_device;
9461     }
9462 
operator <(Device const & rhs) const9463     bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
9464     {
9465       return m_device < rhs.m_device;
9466     }
9467 #endif
9468 
9469     //=== VK_VERSION_1_0 ===
9470 
9471     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9472     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9473 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9474     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9475     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9476 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9477 
9478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9479     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9480                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9481 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9482     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9483     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9484                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9485 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9486 
9487     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9488     void getQueue( uint32_t                      queueFamilyIndex,
9489                    uint32_t                      queueIndex,
9490                    VULKAN_HPP_NAMESPACE::Queue * pQueue,
9491                    Dispatch const & d            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9492 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9493     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9494     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
9495       getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9496 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9497 
9498 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9499     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9500     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9501 #else
9502     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9503     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9504 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9505 
9506     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9507     VULKAN_HPP_NODISCARD Result allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *  pAllocateInfo,
9508                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9509                                                 VULKAN_HPP_NAMESPACE::DeviceMemory *              pMemory,
9510                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9511 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9512     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9513     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type
9514       allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &                    allocateInfo,
9515                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9516                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9517 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9518     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9519     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type
9520       allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &                    allocateInfo,
9521                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9522                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9523 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9524 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9525 
9526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9527     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
9528                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9529                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9531     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9532     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9533                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9534                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9535 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9536 
9537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9538     void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
9539                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9540                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9541 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9543     void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                                  memory,
9544                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9545                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9546 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9547 
9548     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9549     VULKAN_HPP_NODISCARD Result mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
9550                                            VULKAN_HPP_NAMESPACE::DeviceSize     offset,
9551                                            VULKAN_HPP_NAMESPACE::DeviceSize     size,
9552                                            VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
9553                                            void **                              ppData,
9554                                            Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9555 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9556     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9557     VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory         memory,
9558                                                                            VULKAN_HPP_NAMESPACE::DeviceSize           offset,
9559                                                                            VULKAN_HPP_NAMESPACE::DeviceSize           size,
9560                                                                            VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9561                                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9562 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9563 
9564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9565     void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9566 
9567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9568     VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
9569                                                          const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
9570                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9571 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9572     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9573     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9574       flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
9575                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9576 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9577 
9578     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9579     VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t                                        memoryRangeCount,
9580                                                               const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
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       invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
9586                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9587 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9588 
9589     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9590     void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
9591                               VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
9592                               Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9593 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9594     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9595     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
9596       getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9597 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9598 
9599 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9600     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9601     VULKAN_HPP_NODISCARD Result bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
9602                                                   VULKAN_HPP_NAMESPACE::DeviceMemory memory,
9603                                                   VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
9604                                                   Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9605 #else
9606     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9607     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9608       bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
9609                         VULKAN_HPP_NAMESPACE::DeviceMemory memory,
9610                         VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
9611                         Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9612 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9613 
9614 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9615     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9616     VULKAN_HPP_NODISCARD Result bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
9617                                                  VULKAN_HPP_NAMESPACE::DeviceMemory memory,
9618                                                  VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
9619                                                  Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9620 #else
9621     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9622     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9623       bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
9624                        VULKAN_HPP_NAMESPACE::DeviceMemory memory,
9625                        VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
9626                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9627 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9628 
9629     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9630     void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
9631                                       VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
9632                                       Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9633 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9634     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9635     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements
9636       getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9637 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9638 
9639     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9640     void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
9641                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
9642                                      Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9643 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9644     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9645     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements
9646       getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9647 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9648 
9649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9650     void getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                           image,
9651                                            uint32_t *                                            pSparseMemoryRequirementCount,
9652                                            VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
9653                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9654 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9655     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
9656               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9657     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
9658       getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9659     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
9660               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9661               typename std::enable_if<
9662                 std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value,
9663                 int>::type = 0>
9664     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
9665                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
9666                                                            SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
9667                                                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9668 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9669 
9670     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9671     VULKAN_HPP_NODISCARD Result createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
9672                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9673                                              VULKAN_HPP_NAMESPACE::Fence *                     pFence,
9674                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9675 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9676     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9677     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
9678       createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo &                       createInfo,
9679                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9680                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9681 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9682     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9683     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
9684       createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo &                       createInfo,
9685                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9686                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9687 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9688 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9689 
9690     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9691     void destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
9692                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9693                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9694 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9695     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9696     void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9697                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9698                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9699 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9700 
9701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9702     void destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,
9703                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9704                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9705 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9706     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9707     void destroy( VULKAN_HPP_NAMESPACE::Fence                                         fence,
9708                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9709                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9710 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9711 
9712     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9713     VULKAN_HPP_NODISCARD Result resetFences( uint32_t                            fenceCount,
9714                                              const VULKAN_HPP_NAMESPACE::Fence * pFences,
9715                                              Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9716 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9718     typename ResultValueType<void>::type resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
9719                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9720 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9721 
9722 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9723     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9724     VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
9725                                                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9726 #else
9727     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9728     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
9729                                                                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9730 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9731 
9732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9733     VULKAN_HPP_NODISCARD Result waitForFences( uint32_t                            fenceCount,
9734                                                const VULKAN_HPP_NAMESPACE::Fence * pFences,
9735                                                VULKAN_HPP_NAMESPACE::Bool32        waitAll,
9736                                                uint64_t                            timeout,
9737                                                Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9738 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9739     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9740     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
9741                                                                      VULKAN_HPP_NAMESPACE::Bool32                                                waitAll,
9742                                                                      uint64_t                                                                    timeout,
9743                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9744 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9745 
9746     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9747     VULKAN_HPP_NODISCARD Result createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
9748                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9749                                                  VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
9750                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9752     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9753     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
9754       createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &                   createInfo,
9755                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9756                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9757 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9758     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9759     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
9760       createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &                   createInfo,
9761                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9762                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9763 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9764 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9765 
9766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9767     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
9768                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9769                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9770 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9771     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9772     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9773                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9774                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9775 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9776 
9777     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9778     void destroy( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
9779                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9780                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9781 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9782     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9783     void destroy( VULKAN_HPP_NAMESPACE::Semaphore                                     semaphore,
9784                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9785                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9786 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9787 
9788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9789     VULKAN_HPP_NODISCARD Result createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
9790                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9791                                              VULKAN_HPP_NAMESPACE::Event *                     pEvent,
9792                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9793 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9794     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9795     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
9796       createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo &                       createInfo,
9797                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9798                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9799 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9800     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9801     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
9802       createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo &                       createInfo,
9803                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9804                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9805 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9806 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9807 
9808     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9809     void destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
9810                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9811                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9812 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9813     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9814     void destroyEvent( VULKAN_HPP_NAMESPACE::Event event                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9815                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9816                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9817 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9818 
9819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9820     void destroy( VULKAN_HPP_NAMESPACE::Event                       event,
9821                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9822                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9823 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9825     void destroy( VULKAN_HPP_NAMESPACE::Event                                         event,
9826                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9827                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9828 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9829 
9830 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9831     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9832     VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
9833                                                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9834 #else
9835     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9836     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
9837                                                                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9838 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9839 
9840 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9841     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9842     VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event,
9843                                           Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9844 #else
9845     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9846     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setEvent( VULKAN_HPP_NAMESPACE::Event event,
9847                                                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9848 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9849 
9850 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9851     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9852     VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event,
9853                                             Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9854 #else
9855     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9856     typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9857 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9858 
9859     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9860     VULKAN_HPP_NODISCARD Result createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
9861                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9862                                                  VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
9863                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9864 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9865     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9866     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
9867       createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &                   createInfo,
9868                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9869                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9870 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9872     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
9873       createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &                   createInfo,
9874                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9875                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9876 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9877 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9878 
9879     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9880     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
9881                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9882                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9883 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9884     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9885     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9886                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9887                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9888 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9889 
9890     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9891     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
9892                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9893                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9894 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9895     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9896     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                                     queryPool,
9897                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9898                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9899 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9900 
9901     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9902     VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
9903                                                      uint32_t                               firstQuery,
9904                                                      uint32_t                               queryCount,
9905                                                      size_t                                 dataSize,
9906                                                      void *                                 pData,
9907                                                      VULKAN_HPP_NAMESPACE::DeviceSize       stride,
9908                                                      VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
9909                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9910 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9911     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9912     VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>>
9913                          getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
9914                                               uint32_t                                     firstQuery,
9915                                               uint32_t                                     queryCount,
9916                                               size_t                                       dataSize,
9917                                               VULKAN_HPP_NAMESPACE::DeviceSize             stride,
9918                                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9919                                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9920     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9921     VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
9922                                                                    uint32_t                                     firstQuery,
9923                                                                    uint32_t                                     queryCount,
9924                                                                    VULKAN_HPP_NAMESPACE::DeviceSize             stride,
9925                                                                    VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9926                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9927 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9928 
9929     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9930     VULKAN_HPP_NODISCARD Result createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo *    pCreateInfo,
9931                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9932                                               VULKAN_HPP_NAMESPACE::Buffer *                    pBuffer,
9933                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9935     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9936     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type
9937       createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo &                      createInfo,
9938                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9939                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9940 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9941     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9942     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type
9943       createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo &                      createInfo,
9944                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9945                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9946 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9947 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9948 
9949     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9950     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
9951                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9952                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9953 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9954     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9955     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9956                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9957                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9958 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9959 
9960     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9961     void destroy( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
9962                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9963                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9964 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9965     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9966     void destroy( VULKAN_HPP_NAMESPACE::Buffer                                        buffer,
9967                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9968                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9969 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9970 
9971     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9972     VULKAN_HPP_NODISCARD Result createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
9973                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
9974                                                   VULKAN_HPP_NAMESPACE::BufferView *                 pView,
9975                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9976 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9977     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9978     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type
9979       createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &                  createInfo,
9980                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9981                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9982 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9983     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9984     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type
9985       createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &                  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 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9989 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9990 
9991     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9992     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
9993                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9994                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9995 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9996     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9997     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9998                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9999                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10001 
10002     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10003     void destroy( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
10004                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10005                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10006 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10007     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10008     void destroy( VULKAN_HPP_NAMESPACE::BufferView                                    bufferView,
10009                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10010                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10011 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10012 
10013     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10014     VULKAN_HPP_NODISCARD Result createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
10015                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10016                                              VULKAN_HPP_NAMESPACE::Image *                     pImage,
10017                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10018 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10019     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10020     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
10021       createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo &                       createInfo,
10022                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10023                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10024 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10025     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10026     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
10027       createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo &                       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 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10031 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10032 
10033     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10034     void destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
10035                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10036                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10037 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10038     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10039     void destroyImage( VULKAN_HPP_NAMESPACE::Image image                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10040                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10041                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10042 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10043 
10044     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10045     void destroy( VULKAN_HPP_NAMESPACE::Image                       image,
10046                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10047                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10048 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10049     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10050     void destroy( VULKAN_HPP_NAMESPACE::Image                                         image,
10051                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10052                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10054 
10055     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10056     void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
10057                                     const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
10058                                     VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
10059                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10060 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10061     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10062     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout
10063                          getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
10064                                                     const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource,
10065                                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10066 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10067 
10068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10069     VULKAN_HPP_NODISCARD Result createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
10070                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10071                                                  VULKAN_HPP_NAMESPACE::ImageView *                 pView,
10072                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10073 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10074     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10075     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
10076       createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &                   createInfo,
10077                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10078                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10079 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10080     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10081     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
10082       createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &                   createInfo,
10083                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10084                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10085 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10086 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10087 
10088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10089     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
10090                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10091                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10092 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10093     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10094     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10095                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10096                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10097 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10098 
10099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10100     void destroy( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
10101                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10102                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10104     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10105     void destroy( VULKAN_HPP_NAMESPACE::ImageView                                     imageView,
10106                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10107                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10108 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10109 
10110     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10111     VULKAN_HPP_NODISCARD Result createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
10112                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
10113                                                     VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
10114                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10115 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10116     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10117     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
10118       createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,
10119                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10120                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10121 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10122     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10123     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
10124       createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,
10125                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10126                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10127 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10128 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10129 
10130     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10131     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
10132                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10133                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10134 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10135     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10136     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule                     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10137                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10138                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10139 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10140 
10141     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10142     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
10143                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10144                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10145 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10147     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                                  shaderModule,
10148                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10149                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10150 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10151 
10152     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10153     VULKAN_HPP_NODISCARD Result createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
10154                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
10155                                                      VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
10156                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10158     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10159     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
10160       createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &               createInfo,
10161                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10162                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10163 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10164     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10165     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
10166       createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &               createInfo,
10167                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10168                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10169 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10170 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10171 
10172     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10173     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
10174                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10175                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10176 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10177     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10178     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10179                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10180                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10181 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10182 
10183     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10184     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
10185                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10186                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10187 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10188     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10189     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
10190                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10191                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10192 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10193 
10194     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10195     VULKAN_HPP_NODISCARD Result getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
10196                                                       size_t *                            pDataSize,
10197                                                       void *                              pData,
10198                                                       Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10199 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10200     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10201     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
10202       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10203     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
10204               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10205               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
10206     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
10207       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
10208                             Uint8_tAllocator &                  uint8_tAllocator,
10209                             Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10211 
10212     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10213     VULKAN_HPP_NODISCARD Result mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
10214                                                      uint32_t                                    srcCacheCount,
10215                                                      const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
10216                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10217 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10218     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10219     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10220       mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                                                 dstCache,
10221                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
10222                            Dispatch const & d                                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10223 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10224 
10225     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10226     VULKAN_HPP_NODISCARD Result createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
10227                                                          uint32_t                                                 createInfoCount,
10228                                                          const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
10229                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
10230                                                          VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
10231                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10233     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10234     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
10235                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
10236                                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
10237                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10238                                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10239     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
10240               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10241               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
10242     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
10243                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
10244                                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
10245                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                        allocator,
10246                                                   PipelineAllocator &                                                                              pipelineAllocator,
10247                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10249     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
10250                          createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
10251                                                  const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &            createInfo,
10252                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10253                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10254 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10255     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10256               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
10257     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
10258                          createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
10259                                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
10260                                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10261                                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10262     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10263               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
10264               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
10265                                       int>::type = 0>
10266     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
10267                          createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
10268                                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
10269                                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                        allocator,
10270                                                         PipelineAllocator &                                                                              pipelineAllocator,
10271                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10272     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10273     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
10274                          createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
10275                                                        const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &            createInfo,
10276                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10277                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10278 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10279 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10280 
10281     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10282     VULKAN_HPP_NODISCARD Result createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
10283                                                         uint32_t                                                createInfoCount,
10284                                                         const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos,
10285                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
10286                                                         VULKAN_HPP_NAMESPACE::Pipeline *                        pPipelines,
10287                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10288 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10289     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10290     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
10291                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
10292                                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
10293                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10294                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10295     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
10296               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10297               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
10298     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
10299                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
10300                                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
10301                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                       allocator,
10302                                                  PipelineAllocator &                                                                             pipelineAllocator,
10303                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10304     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10305     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
10306                          createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
10307                                                 const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &             createInfo,
10308                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10309                                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10310 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10311     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10312               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
10313     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
10314                          createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
10315                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
10316                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10317                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10318     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10319               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
10320               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
10321                                       int>::type = 0>
10322     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
10323                          createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
10324                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
10325                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                       allocator,
10326                                                        PipelineAllocator &                                                                             pipelineAllocator,
10327                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10329     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
10330                          createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
10331                                                       const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &             createInfo,
10332                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10333                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10334 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10335 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10336 
10337     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10338     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
10339                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10340                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10341 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10342     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10343     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10344                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10345                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10346 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10347 
10348     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10349     void destroy( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
10350                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10351                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10353     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10354     void destroy( VULKAN_HPP_NAMESPACE::Pipeline                                      pipeline,
10355                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10356                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10357 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10358 
10359     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10360     VULKAN_HPP_NODISCARD Result createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
10361                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
10362                                                       VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
10363                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10364 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10365     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10366     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
10367       createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &              createInfo,
10368                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10369                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10370 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10371     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10372     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
10373       createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &              createInfo,
10374                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10375                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10376 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10377 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10378 
10379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10380     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
10381                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10382                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10383 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10384     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10385     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10386                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10387                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10388 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10389 
10390     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10391     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
10392                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10393                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10396     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout                                pipelineLayout,
10397                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10398                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10399 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10400 
10401     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10402     VULKAN_HPP_NODISCARD Result createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
10403                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10404                                                VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
10405                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10406 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10407     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10408     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
10409       createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &                     createInfo,
10410                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10411                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10412 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10413     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10414     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
10415       createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &                     createInfo,
10416                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10417                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10418 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10419 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10420 
10421     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10422     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
10423                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10424                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10425 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10426     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10427     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler                               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10428                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10429                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10430 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10431 
10432     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10433     void destroy( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
10434                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10435                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10436 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10437     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10438     void destroy( VULKAN_HPP_NAMESPACE::Sampler                                       sampler,
10439                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10440                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10441 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10442 
10443     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10444     VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
10445                                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
10446                                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
10447                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10448 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10450     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
10451       createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &         createInfo,
10452                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10453                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10454 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10455     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10456     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
10457       createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &         createInfo,
10458                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10459                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10460 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10461 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10462 
10463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10464     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
10465                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10466                                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10467 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10468     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10469     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10470                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10471                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10472 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10473 
10474     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10475     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
10476                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10477                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10480     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout                           descriptorSetLayout,
10481                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10482                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10483 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10484 
10485     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10486     VULKAN_HPP_NODISCARD Result createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,
10487                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
10488                                                       VULKAN_HPP_NAMESPACE::DescriptorPool *                 pDescriptorPool,
10489                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10490 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10491     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10492     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type
10493       createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &              createInfo,
10494                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10495                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10496 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10497     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10498     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type
10499       createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &              createInfo,
10500                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10501                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10502 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10503 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10504 
10505     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10506     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
10507                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10508                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10509 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10510     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10511     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10512                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10513                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10514 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10515 
10516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10517     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
10518                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10519                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10520 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10521     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10522     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool                                descriptorPool,
10523                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10524                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10525 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10526 
10527 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10528     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10529     Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
10530                                 VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
10531                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10532 #else
10533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10534     void resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool                 descriptorPool,
10535                               VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10536                               Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10537 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10538 
10539     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10540     VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
10541                                                         VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
10542                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10543 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10544     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10545     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
10546       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
10547                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10548     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>,
10549               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10550               typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type = 0>
10551     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
10552       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
10553                               DescriptorSetAllocator &                                descriptorSetAllocator,
10554                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10555 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10556     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10557               typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>
10558     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
10559       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
10560                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10561     template <
10562       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10563       typename DescriptorSetAllocator    = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>,
10564       typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value,
10565                               int>::type = 0>
10566     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
10567       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
10568                                     DescriptorSetAllocator &                                descriptorSetAllocator,
10569                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10570 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10571 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10572 
10573     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10574     Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
10575                                uint32_t                                    descriptorSetCount,
10576                                const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
10577                                Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10578 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10579     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10580     void freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                                                descriptorPool,
10581                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
10582                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10583 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10584 
10585     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10586     Result( free )( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
10587                     uint32_t                                    descriptorSetCount,
10588                     const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
10589                     Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10590 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10591     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10592     void( free )( VULKAN_HPP_NAMESPACE::DescriptorPool                                                descriptorPool,
10593                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
10594                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10595 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10596 
10597     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10598     void updateDescriptorSets( uint32_t                                         descriptorWriteCount,
10599                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
10600                                uint32_t                                         descriptorCopyCount,
10601                                const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
10602                                Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10603 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10604     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10605     void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
10606                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
10607                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10608 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10609 
10610     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10611     VULKAN_HPP_NODISCARD Result createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
10612                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
10613                                                    VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
10614                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10615 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10616     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10617     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
10618       createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &                 createInfo,
10619                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10620                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10621 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10622     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10623     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
10624       createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &                 createInfo,
10625                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10626                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10627 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10628 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10629 
10630     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10631     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
10632                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10633                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10634 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10635     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10636     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer                       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10637                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10638                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10639 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10640 
10641     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10642     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
10643                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10644                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10645 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10646     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10647     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                                   framebuffer,
10648                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10649                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10650 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10651 
10652     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10653     VULKAN_HPP_NODISCARD Result createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
10654                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
10655                                                   VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
10656                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10657 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10659     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
10660       createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &                  createInfo,
10661                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10662                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10663 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10664     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10665     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
10666       createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &                  createInfo,
10667                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10668                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10669 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10670 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10671 
10672     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10673     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
10674                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10675                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10676 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10677     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10678     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10679                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10680                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10681 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10682 
10683     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10684     void destroy( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
10685                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10686                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10687 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10689     void destroy( VULKAN_HPP_NAMESPACE::RenderPass                                    renderPass,
10690                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10691                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10692 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10693 
10694     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10695     void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
10696                                    VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
10697                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10698 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10699     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10700     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
10701                          getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
10702                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10703 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10704 
10705     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10706     VULKAN_HPP_NODISCARD Result createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
10707                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
10708                                                    VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
10709                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10710 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10711     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10712     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
10713       createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &                 createInfo,
10714                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10715                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10716 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10718     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
10719       createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &                 createInfo,
10720                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10721                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10722 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10723 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10724 
10725     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10726     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
10727                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10728                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10729 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10730     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10731     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool                       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10732                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10733                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10734 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10735 
10736     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10737     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
10738                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10739                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10740 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10741     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10742     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                                   commandPool,
10743                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10744                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10745 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10746 
10747 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10749     VULKAN_HPP_NODISCARD Result resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
10750                                                   VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
10751                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10752 #else
10753     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10754     typename ResultValueType<void>::type resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
10755                                                            VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10756                                                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10757 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10758 
10759     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10760     VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
10761                                                         VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
10762                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10763 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10764     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10765     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
10766       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10767                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10768     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>,
10769               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10770               typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type = 0>
10771     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
10772       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10773                               CommandBufferAllocator &                                commandBufferAllocator,
10774                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10775 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10776     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10777               typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>
10778     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
10779       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10780                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10781     template <
10782       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10783       typename CommandBufferAllocator    = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>,
10784       typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value,
10785                               int>::type = 0>
10786     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
10787       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10788                                     CommandBufferAllocator &                                commandBufferAllocator,
10789                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10790 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10791 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10792 
10793     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10794     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
10795                              uint32_t                                    commandBufferCount,
10796                              const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
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     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                                                   commandPool,
10801                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
10802                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10803 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10804 
10805     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10806     void( free )( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
10807                   uint32_t                                    commandBufferCount,
10808                   const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
10809                   Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10810 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10811     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10812     void( free )( VULKAN_HPP_NAMESPACE::CommandPool                                                   commandPool,
10813                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
10814                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10815 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10816 
10817     //=== VK_VERSION_1_1 ===
10818 
10819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10820     VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t                                           bindInfoCount,
10821                                                    const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
10822                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10823 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10825     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10826       bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
10827                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10828 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10829 
10830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10831     VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t                                          bindInfoCount,
10832                                                   const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
10833                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10834 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10835     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10836     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10837       bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
10838                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10839 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10840 
10841     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10842     void getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
10843                                      uint32_t                                       localDeviceIndex,
10844                                      uint32_t                                       remoteDeviceIndex,
10845                                      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
10846                                      Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10848     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10849     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
10850                          getGroupPeerMemoryFeatures( uint32_t           heapIndex,
10851                                                      uint32_t           localDeviceIndex,
10852                                                      uint32_t           remoteDeviceIndex,
10853                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10854 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10855 
10856     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10857     void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
10858                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
10859                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10860 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10862     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10863                          getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10864                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10865     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10866     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10867                          getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10868                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10869 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10870 
10871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10872     void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
10873                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
10874                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10875 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10876     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10877     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10878                          getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10879                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10880     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10881     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10882                          getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10883                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10884 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10885 
10886     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10887     void getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
10888                                             uint32_t *                                                       pSparseMemoryRequirementCount,
10889                                             VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
10890                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10891 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10892     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10893               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10894     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10895                          getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10896                                                             Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10897     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10898               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10899               typename std::enable_if<
10900                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
10901                 int>::type = 0>
10902     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10903                          getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10904                                                             SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
10905                                                             Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10906 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10907 
10908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10909     void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
10910                           VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
10911                           Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10912 
10913     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10914     void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
10915                     VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
10916                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10917 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10919     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo,
10920                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10921 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10922 
10923     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10924     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
10925                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
10926                                                               VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
10927                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10928 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10929     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10930     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
10931       createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
10932                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10933                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10934 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10935     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10936     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
10937       createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
10938                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10939                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10940 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10941 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10942 
10943     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10944     void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
10945                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10946                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10948     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10949     void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10950                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10951                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10952 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10953 
10954     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10955     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
10956                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10957                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10958 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10959     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10960     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion                        ycbcrConversion,
10961                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10962                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10964 
10965     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10966     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
10967                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
10968                                                                 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
10969                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10970 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10971     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10972     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
10973       createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,
10974                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10975                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10976 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10977     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10978     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
10979       createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,
10980                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10981                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10982 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10983 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10984 
10985     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10986     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
10987                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10988                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10990     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10991     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10992                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10993                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10994 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10995 
10996     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10997     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
10998                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10999                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11000 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11001     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11002     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate                      descriptorUpdateTemplate,
11003                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11004                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11005 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11006 
11007     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11008     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
11009                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11010                                           const void *                                   pData,
11011                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11012 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11013     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11014     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
11015                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11016                                           DataType const &                               data,
11017                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11018 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11019 
11020     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11021     void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
11022                                         VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
11023                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11024 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11025     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11026     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
11027                          getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
11028                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11029     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11030     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11031                          getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
11032                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11033 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11034 
11035     //=== VK_VERSION_1_2 ===
11036 
11037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11038     VULKAN_HPP_NODISCARD Result createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
11039                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
11040                                                    VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
11041                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11043     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11044     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
11045       createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
11046                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11047                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11048 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11049     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11050     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
11051       createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
11052                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11053                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11054 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11055 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11056 
11057     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11058     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
11059                          uint32_t                        firstQuery,
11060                          uint32_t                        queryCount,
11061                          Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11062 
11063     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11064     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
11065                                                           uint64_t *                      pValue,
11066                                                           Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11069     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
11070                                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11071 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11072 
11073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11074     VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
11075                                                 uint64_t                                        timeout,
11076                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11077 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11078     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11079     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
11080                                                                       uint64_t                                        timeout,
11081                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11082 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11083 
11084     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11085     VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
11086                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11087 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11089     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11090       signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11091 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11092 
11093     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11094     DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11095                                     Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11096 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11097     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11098     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11099                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11100 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11101 
11102     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11103     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11104                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11105 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11107     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11108                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11110 
11111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11112     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
11113                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11115     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11116     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
11117                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11118 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11119 
11120     //=== VK_VERSION_1_3 ===
11121 
11122     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11123     VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,
11124                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
11125                                                        VULKAN_HPP_NAMESPACE::PrivateDataSlot *                 pPrivateDataSlot,
11126                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11127 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11128     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11129     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type
11130       createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
11131                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11132                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11133 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11135     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type
11136       createPrivateDataSlotUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
11137                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11138                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11139 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11140 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11141 
11142     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11143     void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,
11144                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11145                                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11146 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11147     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11148     void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11149                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11150                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11151 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11152 
11153     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11154     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,
11155                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11156                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11158     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11159     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot                               privateDataSlot,
11160                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11161                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11162 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11163 
11164 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11165     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11166     VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
11167                                                 uint64_t                              objectHandle,
11168                                                 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
11169                                                 uint64_t                              data,
11170                                                 Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11171 #else
11172     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11173     typename ResultValueType<void>::type setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
11174                                                          uint64_t                              objectHandle,
11175                                                          VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
11176                                                          uint64_t                              data,
11177                                                          Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11178 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11179 
11180     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11181     void getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
11182                          uint64_t                              objectHandle,
11183                          VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
11184                          uint64_t *                            pData,
11185                          Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11186 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11187     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11188     VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
11189                                                   uint64_t                              objectHandle,
11190                                                   VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
11191                                                   Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11192 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11193 
11194     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11195     void getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,
11196                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                  pMemoryRequirements,
11197                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11198 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11199     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11200     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
11201                          getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
11202                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11203     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11204     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11205                          getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
11206                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11207 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11208 
11209     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11210     void getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
11211                                      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
11212                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11213 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11214     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11215     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
11216                          getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
11217                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11218     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11219     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11220                          getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
11221                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11222 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11223 
11224     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11225     void getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
11226                                            uint32_t *                                                  pSparseMemoryRequirementCount,
11227                                            VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *      pSparseMemoryRequirements,
11228                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11229 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11230     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
11231               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11232     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11233                          getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
11234                                                            Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11235     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
11236               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11237               typename std::enable_if<
11238                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
11239                 int>::type = 0>
11240     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11241                          getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
11242                                                            SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
11243                                                            Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11245 
11246     //=== VK_KHR_swapchain ===
11247 
11248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11249     VULKAN_HPP_NODISCARD Result createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
11250                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
11251                                                     VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
11252                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11253 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11254     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11255     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
11256       createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
11257                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11258                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11259 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11260     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11261     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
11262       createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
11263                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11264                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11265 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11266 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11267 
11268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11269     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
11270                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11271                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11272 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11273     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11274     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain                        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11275                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11276                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11277 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11278 
11279     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11280     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
11281                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11282                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11284     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11285     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                                  swapchain,
11286                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11287                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11288 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11289 
11290     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11291     VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11292                                                        uint32_t *                         pSwapchainImageCount,
11293                                                        VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
11294                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11296     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11297     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type
11298       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11299     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>,
11300               typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11301               typename std::enable_if<std::is_same<typename ImageAllocator::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type = 0>
11302     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR(
11303       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11304 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11305 
11306     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11307     VULKAN_HPP_NODISCARD Result acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11308                                                      uint64_t                           timeout,
11309                                                      VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
11310                                                      VULKAN_HPP_NAMESPACE::Fence        fence,
11311                                                      uint32_t *                         pImageIndex,
11312                                                      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11313 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11314     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11315     VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR        swapchain,
11316                                                                     uint64_t                                  timeout,
11317                                                                     VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11318                                                                     VULKAN_HPP_NAMESPACE::Fence fence         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11319                                                                     Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11320 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11321 
11322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11323     VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
11324                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11325 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11326     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11327     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
11328       getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11329 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11330 
11331     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11332     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
11333                                                                 VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
11334                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11335 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11336     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11337     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
11338       getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11339 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11340 
11341     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11342     VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
11343                                                       uint32_t *                                            pImageIndex,
11344                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11345 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11346     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11347     VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo,
11348                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11349 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11350 
11351     //=== VK_KHR_display_swapchain ===
11352 
11353     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11354     VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t                                             swapchainCount,
11355                                                            const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
11356                                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
11357                                                            VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
11358                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11359 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11360     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11361     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
11362       createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
11363                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11364                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11365     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>,
11366               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11367               typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type = 0>
11368     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
11369       createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
11370                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,
11371                                  SwapchainKHRAllocator &                                                                      swapchainKHRAllocator,
11372                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11374     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
11375       createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
11376                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11377                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11378 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11379     template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11380               typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>
11381     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
11382       createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
11383                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11384                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11385     template <
11386       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11387       typename SwapchainKHRAllocator     = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>,
11388       typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value,
11389                               int>::type = 0>
11390     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
11391       createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
11392                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,
11393                                        SwapchainKHRAllocator &                                                                      swapchainKHRAllocator,
11394                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11396     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
11397       createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
11398                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11399                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11400 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11401 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11402 
11403     //=== VK_EXT_debug_marker ===
11404 
11405     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11406     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
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_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11411       debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo,
11412                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11413 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11414 
11415     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11416     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
11417                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11418 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11420     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11421       debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo,
11422                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11423 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11424 
11425     //=== VK_KHR_video_queue ===
11426 
11427     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11428     VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
11429                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
11430                                                        VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
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<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
11435       createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,
11436                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11437                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11438 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11439     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11440     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
11441       createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,
11442                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11443                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11444 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11445 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11446 
11447     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11448     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
11449                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11450                                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11451 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11452     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11453     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession                  VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11454                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11455                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11456 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11457 
11458     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11459     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
11460                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11461                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11462 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11464     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR                               videoSession,
11465                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11466                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11467 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11468 
11469     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11470     VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                     videoSession,
11471                                                                       uint32_t *                                                pMemoryRequirementsCount,
11472                                                                       VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements,
11473                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11474 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11475     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
11476               typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11477     VULKAN_HPP_NODISCARD
11478       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
11479       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
11480                                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11481     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
11482               typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11483               typename std::enable_if<
11484                 std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value,
11485                 int>::type = 0>
11486     VULKAN_HPP_NODISCARD
11487       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
11488       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR        videoSession,
11489                                             VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,
11490                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11491 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11492 
11493     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11494     VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                       videoSession,
11495                                                            uint32_t                                                    bindSessionMemoryInfoCount,
11496                                                            const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,
11497                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11498 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11499     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11500     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11501       bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                                                               videoSession,
11502                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos,
11503                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11504 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11505 
11506     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11507     VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
11508                                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
11509                                                                  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
11510                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11511 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11512     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11513     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
11514       createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,
11515                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11516                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11517 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11518     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11519     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
11520       createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,
11521                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11522                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11523 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11524 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11525 
11526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11527     VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
11528                                                                  const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
11529                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11530 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11531     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11532     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11533       updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
11534                                        const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo,
11535                                        Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11536 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11537 
11538     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11539     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
11540                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11541                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11542 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11543     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11544     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11545                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11546                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11547 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11548 
11549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11550     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
11551                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11552                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11553 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11554     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11555     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                     videoSessionParameters,
11556                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11557                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11558 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11559 
11560     //=== VK_NVX_binary_import ===
11561 
11562     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11563     VULKAN_HPP_NODISCARD Result createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
11564                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
11565                                                    VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
11566                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11567 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11568     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11569     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
11570       createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,
11571                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11572                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11573 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11574     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11575     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
11576       createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,
11577                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11578                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11579 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11580 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11581 
11582     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11583     VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
11584                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
11585                                                      VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
11586                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11587 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11588     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11589     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
11590       createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,
11591                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11592                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11593 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11594     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11595     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
11596       createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,
11597                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11598                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11599 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11600 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11601 
11602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11603     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
11604                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11605                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11606 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11607     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11608     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,
11609                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11610                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11611 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11612 
11613     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11614     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
11615                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11616                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11617 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11619     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,
11620                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
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 destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
11626                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11627                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11628 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11629     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11630     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,
11631                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11632                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11633 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11634 
11635     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11636     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
11637                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11638                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11639 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11640     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11641     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,
11642                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11643                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11644 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11645 
11646     //=== VK_NVX_image_view_handle ===
11647 
11648     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11649     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
11650                                     Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11651 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11652     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11653     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info,
11654                                     Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11655 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11656 
11657     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11658     VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
11659                                                         VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
11660                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11661 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11662     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11663     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
11664       getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11665 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11666 
11667     //=== VK_AMD_shader_info ===
11668 
11669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11670     VULKAN_HPP_NODISCARD Result getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
11671                                                   VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
11672                                                   VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
11673                                                   size_t *                                  pInfoSize,
11674                                                   void *                                    pInfo,
11675                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11676 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11677     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11678     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
11679       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
11680                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
11681                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
11682                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11683     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
11684               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11685               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
11686     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
11687       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
11688                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
11689                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
11690                         Uint8_tAllocator &                        uint8_tAllocator,
11691                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11692 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11693 
11694 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11695     //=== VK_NV_external_memory_win32 ===
11696 
11697     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11698     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
11699                                                         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
11700                                                         HANDLE *                                              pHandle,
11701                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11702 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11703     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11704     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
11705                                                                                         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
11706                                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11707 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11708 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
11709 
11710     //=== VK_KHR_device_group ===
11711 
11712     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11713     void getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
11714                                         uint32_t                                       localDeviceIndex,
11715                                         uint32_t                                       remoteDeviceIndex,
11716                                         VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
11717                                         Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11718 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11719     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11720     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
11721                          getGroupPeerMemoryFeaturesKHR( uint32_t           heapIndex,
11722                                                         uint32_t           localDeviceIndex,
11723                                                         uint32_t           remoteDeviceIndex,
11724                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11725 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11726 
11727     //=== VK_KHR_maintenance1 ===
11728 
11729     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11730     void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
11731                              VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
11732                              Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11733 
11734 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11735     //=== VK_KHR_external_memory_win32 ===
11736 
11737     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11738     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
11739                                                          HANDLE *                                                  pHandle,
11740                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11741 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11742     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11743     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type
11744       getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
11745                                Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11746 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11747 
11748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11749     VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11750                                                                    HANDLE                                                 handle,
11751                                                                    VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
11752                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11753 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11754     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11755     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR(
11756       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11757 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11758 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
11759 
11760     //=== VK_KHR_external_memory_fd ===
11761 
11762     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11763     VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
11764                                                 int *                                            pFd,
11765                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11766 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11767     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11768     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo,
11769                                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11770 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11771 
11772     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11773     VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11774                                                           int                                                    fd,
11775                                                           VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
11776                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11777 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11778     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11779     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR(
11780       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11781 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11782 
11783 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11784     //=== VK_KHR_external_semaphore_win32 ===
11785 
11786     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11787     VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
11788                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11789 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11790     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11791     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11792       importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
11793                                      Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11794 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11795 
11796     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11797     VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
11798                                                             HANDLE *                                                     pHandle,
11799                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11800 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11801     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11802     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type
11803       getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
11804                                   Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11805 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11806 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
11807 
11808     //=== VK_KHR_external_semaphore_fd ===
11809 
11810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11811     VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
11812                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11813 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11815     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11816       importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
11817                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11818 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11819 
11820     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11821     VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
11822                                                    int *                                               pFd,
11823                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11824 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11825     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11826     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo,
11827                                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11828 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11829 
11830     //=== VK_KHR_descriptor_update_template ===
11831 
11832     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11833     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
11834                                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
11835                                                                    VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
11836                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11837 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11838     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11839     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
11840       createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,
11841                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11842                                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11843 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11844     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11845     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
11846       createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
11847                                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11848                                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11849                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11850 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11851 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11852 
11853     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11854     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
11855                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11856                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11857 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11858     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11859     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11860                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11861                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11862 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11863 
11864     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11865     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
11866                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11867                                              const void *                                   pData,
11868                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11869 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11870     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11871     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
11872                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11873                                              DataType const &                               data,
11874                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11875 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11876 
11877     //=== VK_EXT_display_control ===
11878 
11879     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11880     VULKAN_HPP_NODISCARD Result displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
11881                                                         const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
11882                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11883 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11884     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11885     typename ResultValueType<void>::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
11886                                                                  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo,
11887                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11888 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11889 
11890     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11891     VULKAN_HPP_NODISCARD Result registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
11892                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11893                                                   VULKAN_HPP_NAMESPACE::Fence *                     pFence,
11894                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11895 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11896     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11897     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
11898       registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &                    deviceEventInfo,
11899                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11900                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11901 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11902     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11903     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
11904       registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &                    deviceEventInfo,
11905                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11906                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11907 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11908 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11909 
11910     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11911     VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
11912                                                          const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
11913                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11914                                                          VULKAN_HPP_NAMESPACE::Fence *                     pFence,
11915                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11916 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11917     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11918     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
11919       registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
11920                                const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &                   displayEventInfo,
11921                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11922                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11923 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11924     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11925     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
11926       registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
11927                                      const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &                   displayEventInfo,
11928                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11929                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11930 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11931 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11932 
11933     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11934     VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
11935                                                         VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
11936                                                         uint64_t *                                      pCounterValue,
11937                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11938 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11939     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11940     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
11941                                                                                           VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
11942                                                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11943 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11944 
11945     //=== VK_GOOGLE_display_timing ===
11946 
11947     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11948     VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
11949                                                                VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
11950                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11951 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11952     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11953     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
11954       getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11955 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11956 
11957     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11958     VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
11959                                                                  uint32_t *                                           pPresentationTimingCount,
11960                                                                  VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
11961                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11962 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11963     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
11964               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11965     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
11966       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11967     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
11968               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11969               typename std::enable_if<
11970                 std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value,
11971                 int>::type = 0>
11972     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
11973       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
11974                                        PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
11975                                        Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11976 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11977 
11978     //=== VK_EXT_hdr_metadata ===
11979 
11980     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11981     void setHdrMetadataEXT( uint32_t                                     swapchainCount,
11982                             const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
11983                             const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
11984                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11985 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11986     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11987     void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
11988                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
11989                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
11990 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11991 
11992     //=== VK_KHR_create_renderpass2 ===
11993 
11994     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11995     VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
11996                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
11997                                                       VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
11998                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11999 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12000     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12001     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
12002       createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
12003                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12004                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12005 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12007     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
12008       createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
12009                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12010                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12011 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12012 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12013 
12014     //=== VK_KHR_shared_presentable_image ===
12015 
12016 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12018     VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12019                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12020 #else
12021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12022     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12023                                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12024 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12025 
12026 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12027     //=== VK_KHR_external_fence_win32 ===
12028 
12029     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12030     VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
12031                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12032 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12033     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12034     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12035       importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
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 getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
12041                                                         HANDLE *                                                 pHandle,
12042                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12043 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12044     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12045     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type
12046       getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
12047                               Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12048 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12049 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
12050 
12051     //=== VK_KHR_external_fence_fd ===
12052 
12053     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12054     VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
12055                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12056 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12057     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12058     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12059       importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo,
12060                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12061 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12062 
12063     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12064     VULKAN_HPP_NODISCARD Result getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
12065                                                int *                                           pFd,
12066                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12069     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo,
12070                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12071 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12072 
12073     //=== VK_KHR_performance_query ===
12074 
12075     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12076     VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
12077                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12078 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12080     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12081       acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info,
12082                                Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12083 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12084 
12085     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12086     void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12087 
12088     //=== VK_EXT_debug_utils ===
12089 
12090     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12091     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
12092                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12093 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12094     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12095     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12096       setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo,
12097                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12098 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12099 
12100     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12101     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
12102                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12104     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12105     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12106       setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo,
12107                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12108 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12109 
12110 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
12111     //=== VK_ANDROID_external_memory_android_hardware_buffer ===
12112 
12113     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12114     VULKAN_HPP_NODISCARD Result
12115       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer *                                 buffer,
12116                                                  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
12117                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12118 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12119     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12120     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
12121       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12122     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12123     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
12124       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12125 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12126 
12127     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12128     VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
12129                                                                        struct AHardwareBuffer **                                               pBuffer,
12130                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12131 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12132     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12133     VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type
12134       getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info,
12135                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12136 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12137 #endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
12138 
12139 #if defined( VK_ENABLE_BETA_EXTENSIONS )
12140     //=== VK_AMDX_shader_enqueue ===
12141 
12142     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12143     VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache                                pipelineCache,
12144                                                                    uint32_t                                                           createInfoCount,
12145                                                                    const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
12146                                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
12147                                                                    VULKAN_HPP_NAMESPACE::Pipeline *                                   pPipelines,
12148                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12149 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12150     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12151     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
12152                          createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
12153                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
12154                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12155                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12156     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
12157               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12158               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
12159     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
12160                          createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
12161                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
12162                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                                  allocator,
12163                                                             PipelineAllocator & pipelineAllocator,
12164                                                             Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12165     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12166     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
12167                          createExecutionGraphPipelineAMDX( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
12168                                                            const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX &  createInfo,
12169                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12170                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12171 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
12172     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12173               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
12174     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
12175                          createExecutionGraphPipelinesAMDXUnique(
12176                            VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,
12177                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
12178                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12179                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12180     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12181               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
12182               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
12183                                       int>::type = 0>
12184     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
12185                          createExecutionGraphPipelinesAMDXUnique(
12186                            VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,
12187                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
12188                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                                  allocator,
12189                            PipelineAllocator &                                                                                        pipelineAllocator,
12190                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12192     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createExecutionGraphPipelineAMDXUnique(
12193       VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
12194       const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX &  createInfo,
12195       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12196       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12197 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
12198 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12199 
12200     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12201     VULKAN_HPP_NODISCARD Result
12202       getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                executionGraph,
12203                                                 VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo,
12204                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12205 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12207     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX>::type
12208       getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph,
12209                                                 Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12210 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12211 
12212     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12213     VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                      executionGraph,
12214                                                                         const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
12215                                                                         uint32_t *                                                          pNodeIndex,
12216                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12217 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12218     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12219     VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type
12220       getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                      executionGraph,
12221                                               const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo,
12222                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12223 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12224 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
12225 
12226     //=== VK_KHR_get_memory_requirements2 ===
12227 
12228     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12229     void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
12230                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
12231                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12233     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12234     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
12235                          getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
12236                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12237     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12238     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12239                          getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
12240                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12241 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12242 
12243     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12244     void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
12245                                           VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
12246                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12247 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12249     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
12250                          getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
12251                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12252     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12253     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12254                          getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
12255                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12256 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12257 
12258     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12259     void getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
12260                                                uint32_t *                                                       pSparseMemoryRequirementCount,
12261                                                VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
12262                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12263 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12264     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
12265               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12266     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12267                          getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
12268                                                                Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12269     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
12270               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12271               typename std::enable_if<
12272                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
12273                 int>::type = 0>
12274     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12275                          getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
12276                                                                SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
12277                                                                Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12278 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12279 
12280     //=== VK_KHR_acceleration_structure ===
12281 
12282     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12283     VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
12284                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
12285                                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
12286                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12287 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12288     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12289     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
12290       createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,
12291                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12292                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12293 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12294     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12295     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
12296       createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,
12297                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12298                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12299 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12300 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12301 
12302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12303     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
12304                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12309                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12310                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12311 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12312 
12313     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12314     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
12315                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12316                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12317 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12318     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12319     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR                      accelerationStructure,
12320                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12321                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12322 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12323 
12324     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12325     VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
12326                                                                 uint32_t                                                                     infoCount,
12327                                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
12328                                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
12329                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12331     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12332     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR(
12333       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                                           deferredOperation,
12334       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
12335       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
12336       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12337 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12338 
12339     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12340     VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
12341                                                               const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
12342                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12343 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12344     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12345     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
12346                                                                                     const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
12347                                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12348 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12349 
12350     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12351     VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
12352                                                                       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
12353                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12354 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12355     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12356     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
12357                          copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
12358                                                                const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
12359                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12360 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12361 
12362     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12363     VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
12364                                                                       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
12365                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12368     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
12369                          copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
12370                                                                const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
12371                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12373 
12374     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12375     VULKAN_HPP_NODISCARD Result
12376       writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,
12377                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
12378                                                 VULKAN_HPP_NAMESPACE::QueryType                        queryType,
12379                                                 size_t                                                 dataSize,
12380                                                 void *                                                 pData,
12381                                                 size_t                                                 stride,
12382                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12383 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12384     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12385     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeAccelerationStructuresPropertiesKHR(
12386       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
12387       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,
12388       size_t                                                                                         dataSize,
12389       size_t                                                                                         stride,
12390       Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12391     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12392     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeAccelerationStructuresPropertyKHR(
12393       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
12394       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,
12395       size_t                                                                                         stride,
12396       Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12397 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12398 
12399     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12400     DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
12401                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12404     VULKAN_HPP_NAMESPACE::DeviceAddress
12405       getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info,
12406                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12407 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12408 
12409     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12410     void getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
12411                                                    VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
12412                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12414     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12415     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
12416                          getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo,
12417                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12418 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12419 
12420     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12421     void getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
12422                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
12423                                                 const uint32_t *                                                        pMaxPrimitiveCounts,
12424                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
12425                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12426 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12427     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12428     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(
12429       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                     buildType,
12430       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR &     buildInfo,
12431       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12432       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
12433 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12434 
12435     //=== VK_KHR_ray_tracing_pipeline ===
12436 
12437     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12438     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
12439                                                               VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
12440                                                               uint32_t                                                      createInfoCount,
12441                                                               const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,
12442                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *             pAllocator,
12443                                                               VULKAN_HPP_NAMESPACE::Pipeline *                              pPipelines,
12444                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12445 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12446     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12447     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
12448                          createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,
12449                                                        VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,
12450                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
12451                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12452                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12453     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
12454               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12455               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
12456     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
12457                          createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,
12458                                                        VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,
12459                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
12460                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,
12461                                                        PipelineAllocator &                                                                                   pipelineAllocator,
12462                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12464     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
12465                          createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,
12466                                                       VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
12467                                                       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,
12468                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12469                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12470 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12471     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12472               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
12473     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
12474                          createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
12475                                                              VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
12476                                                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
12477                                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12478                                                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12479     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12480               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
12481               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
12482                                       int>::type = 0>
12483     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
12484                          createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
12485                                                              VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
12486                                                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
12487                                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,
12488                                                              PipelineAllocator & pipelineAllocator,
12489                                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12490     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12491     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
12492                          createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,
12493                                                             VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
12494                                                             const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,
12495                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12496                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12497 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12498 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12499 
12500     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12501     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12502                                                                     uint32_t                       firstGroup,
12503                                                                     uint32_t                       groupCount,
12504                                                                     size_t                         dataSize,
12505                                                                     void *                         pData,
12506                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12507 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12508     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12509     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
12510       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12511                                           uint32_t                       firstGroup,
12512                                           uint32_t                       groupCount,
12513                                           size_t                         dataSize,
12514                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12515     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12516     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR(
12517       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12519 
12520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12521     VULKAN_HPP_NODISCARD Result
12522       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12523                                                        uint32_t                       firstGroup,
12524                                                        uint32_t                       groupCount,
12525                                                        size_t                         dataSize,
12526                                                        void *                         pData,
12527                                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12528 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12529     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12530     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
12531       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12532                                                        uint32_t                       firstGroup,
12533                                                        uint32_t                       groupCount,
12534                                                        size_t                         dataSize,
12535                                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12536     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12537     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR(
12538       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12539 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12540 
12541     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12542     DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline             pipeline,
12543                                                      uint32_t                                   group,
12544                                                      VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader,
12545                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12546 
12547     //=== VK_KHR_sampler_ycbcr_conversion ===
12548 
12549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12550     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
12551                                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
12552                                                                  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
12553                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12554 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12555     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12556     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
12557       createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
12558                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12559                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12560 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12561     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12562     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
12563       createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
12564                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12565                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12566 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12567 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12568 
12569     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12570     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
12571                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12572                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12573 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12574     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12575     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12576                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12577                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12578 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12579 
12580     //=== VK_KHR_bind_memory2 ===
12581 
12582     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12583     VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
12584                                                       const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
12585                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12586 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12587     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12588     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12589       bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
12590                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12591 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12592 
12593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12594     VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t                                          bindInfoCount,
12595                                                      const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
12596                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12597 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12599     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12600       bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
12601                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12602 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12603 
12604     //=== VK_EXT_image_drm_format_modifier ===
12605 
12606     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12607     VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image                                 image,
12608                                                                         VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
12609                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12610 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12611     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12612     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
12613       getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12614 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12615 
12616     //=== VK_EXT_validation_cache ===
12617 
12618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12619     VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
12620                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
12621                                                           VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
12622                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12623 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12624     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12625     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type
12626       createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,
12627                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12628                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12629 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12630     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12631     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
12632       createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,
12633                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12634                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12635 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12636 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12637 
12638     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12639     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
12640                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12641                                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12642 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12644     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache            VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12645                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12646                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12647 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12648 
12649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12650     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
12651                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12652                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12653 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12654     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12655     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                            validationCache,
12656                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12657                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12658 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12659 
12660     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12661     VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
12662                                                           uint32_t                                         srcCacheCount,
12663                                                           const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
12664                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12665 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12666     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12667     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12668       mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                                                 dstCache,
12669                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
12670                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12671 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12672 
12673     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12674     VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
12675                                                            size_t *                                 pDataSize,
12676                                                            void *                                   pData,
12677                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12678 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12679     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12680     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
12681       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12682     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
12683               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12684               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
12685     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
12686       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
12687                                  Uint8_tAllocator &                       uint8_tAllocator,
12688                                  Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12689 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12690 
12691     //=== VK_NV_ray_tracing ===
12692 
12693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12694     VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
12695                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
12696                                                                VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,
12697                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12698 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12699     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12700     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type
12701       createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,
12702                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12703                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12704 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12705     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12706     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
12707       createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,
12708                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12709                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12710 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12711 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12712 
12713     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12714     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
12715                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12716                                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12718     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12719     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12720                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12721                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12722 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12723 
12724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12725     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
12726                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12727                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12728 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12729     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12730     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV                       accelerationStructure,
12731                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12732                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12733 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12734 
12735     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12736     void getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
12737                                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
12738                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12739 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12740     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12741     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR
12742                          getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
12743                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12744     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12745     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12746                          getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
12747                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12748 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12749 
12750     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12751     VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t                                                            bindInfoCount,
12752                                                                    const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
12753                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12754 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12755     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12756     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12757       bindAccelerationStructureMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
12758                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12759 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12760 
12761     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12762     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
12763                                                              uint32_t                                                     createInfoCount,
12764                                                              const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
12765                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
12766                                                              VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
12767                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12768 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12769     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12770     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
12771                          createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
12772                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12773                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12774                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12775     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
12776               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12777               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
12778     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
12779                          createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
12780                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12781                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,
12782                                                       PipelineAllocator &                                                                                  pipelineAllocator,
12783                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12784     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12785     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
12786                          createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
12787                                                      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,
12788                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12789                                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12790 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12791     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12792               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
12793     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
12794                          createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
12795                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12796                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12797                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12798     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12799               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
12800               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
12801                                       int>::type = 0>
12802     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
12803                          createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
12804                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12805                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,
12806                                                             PipelineAllocator &                                                                                  pipelineAllocator,
12807                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12808     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12809     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
12810                          createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
12811                                                            const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,
12812                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12813                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12814 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12815 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12816 
12817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12818     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12819                                                                    uint32_t                       firstGroup,
12820                                                                    uint32_t                       groupCount,
12821                                                                    size_t                         dataSize,
12822                                                                    void *                         pData,
12823                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12824 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12825     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12826     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
12827       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12828                                          uint32_t                       firstGroup,
12829                                          uint32_t                       groupCount,
12830                                          size_t                         dataSize,
12831                                          Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12832     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12833     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV(
12834       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12835 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12836 
12837     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12838     VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
12839                                                                   size_t                                        dataSize,
12840                                                                   void *                                        pData,
12841                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12843     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12844     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV(
12845       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12846     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12847     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
12848       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
12849                                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12850 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12851 
12852 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12853     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12854     VULKAN_HPP_NODISCARD Result compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12855                                                    uint32_t                       shader,
12856                                                    Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12857 #else
12858     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12859     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12860       compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12861 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12862 
12863     //=== VK_KHR_maintenance3 ===
12864 
12865     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12866     void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
12867                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
12868                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12869 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12870     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12871     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
12872                          getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
12873                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12874     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12875     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12876                          getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
12877                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12878 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12879 
12880     //=== VK_EXT_external_memory_host ===
12881 
12882     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12883     VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
12884                                                                    const void *                                           pHostPointer,
12885                                                                    VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
12886                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12887 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12888     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12889     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
12890       getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
12891                                          const void *                                           pHostPointer,
12892                                          Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12894 
12895     //=== VK_EXT_calibrated_timestamps ===
12896 
12897     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12898     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t                                                 timestampCount,
12899                                                             const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
12900                                                             uint64_t *                                               pTimestamps,
12901                                                             uint64_t *                                               pMaxDeviation,
12902                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12903 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12904     template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12905     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
12906       getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
12907                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12908     template <typename Uint64_tAllocator                                                                                = std::allocator<uint64_t>,
12909               typename Dispatch                                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12910               typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
12911     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
12912       getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
12913                                   Uint64_tAllocator &                                                                              uint64_tAllocator,
12914                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12915     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12916     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
12917       getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
12918                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12919 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12920 
12921     //=== VK_KHR_timeline_semaphore ===
12922 
12923     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12924     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
12925                                                              uint64_t *                      pValue,
12926                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12927 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12928     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12929     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type
12930       getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12931 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12932 
12933     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12934     VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
12935                                                    uint64_t                                        timeout,
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 VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
12940                                                                          uint64_t                                        timeout,
12941                                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12942 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12943 
12944     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12945     VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
12946                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12948     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12949     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12950       signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12951 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12952 
12953     //=== VK_INTEL_performance_query ===
12954 
12955     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12956     VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
12957                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12958 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12959     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12960     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12961       initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo,
12962                                      Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12964 
12965     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12966     void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12967 
12968     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12969     VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
12970                                                                       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
12971                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12972 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12973     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12974     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
12975       acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
12976                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12977 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12978     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12979     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
12980       acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
12981                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12982 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12983 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12984 
12985 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12986     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12987     VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
12988                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12989 #else
12990     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12991     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12992       releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12993                                             Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12994 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12995 
12996 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12997     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12998     VULKAN_HPP_NODISCARD Result release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
12999                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13000 #else
13001     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13002     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
13003                                                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13004 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13005 
13006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13007     VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
13008                                                               VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
13009                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13010 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13011     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13012     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
13013       getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
13014                                     Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13015 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13016 
13017     //=== VK_AMD_display_native_hdr ===
13018 
13019     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13020     void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
13021                              VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
13022                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13023 
13024     //=== VK_EXT_buffer_device_address ===
13025 
13026     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13027     DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
13028                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13029 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13031     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
13032                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13033 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13034 
13035     //=== VK_KHR_present_wait ===
13036 
13037 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13038     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13039     VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13040                                                    uint64_t                           presentId,
13041                                                    uint64_t                           timeout,
13042                                                    Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13043 #else
13044     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13045     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13046                                                                          uint64_t                           presentId,
13047                                                                          uint64_t                           timeout,
13048                                                                          Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13049 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13050 
13051 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13052     //=== VK_EXT_full_screen_exclusive ===
13053 
13054 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13055     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13056     VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13057                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13058 #  else
13059     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13060     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13061       acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13062 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13063 
13064 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13065     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13066     VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13067                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13068 #  else
13069     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13070     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13071       releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13072 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13073 
13074     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13075     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
13076                                                                  VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
13077                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13078 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13080     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
13081       getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13082                                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13083 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13084 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
13085 
13086     //=== VK_KHR_buffer_device_address ===
13087 
13088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13089     DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
13090                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13092     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13093     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
13094                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13095 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13096 
13097     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13098     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
13099                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13100 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13101     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13102     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
13103                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13104 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13105 
13106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13107     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
13108                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13109 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13110     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13111     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
13112                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13113 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13114 
13115     //=== VK_EXT_host_query_reset ===
13116 
13117     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13118     void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
13119                             uint32_t                        firstQuery,
13120                             uint32_t                        queryCount,
13121                             Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13122 
13123     //=== VK_KHR_deferred_host_operations ===
13124 
13125     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13126     VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13127                                                             VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
13128                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13129 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13130     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13131     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type
13132       createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13133                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13134 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13135     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13136     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
13137       createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13138                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13139 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13140 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13141 
13142     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13143     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
13144                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation                VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13149                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13150                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13151 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13152 
13153     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13154     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
13155                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13156                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13158     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13159     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          operation,
13160                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13161                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13162 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13163 
13164     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13165     uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
13166                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13167 
13168 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13169     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13170     VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
13171                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13172 #else
13173     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13174     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
13175                          getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
13176                                                         Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13177 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13178 
13179 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13180     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13181     VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
13182                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13183 #else
13184     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13185     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
13186                                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13187 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13188 
13189     //=== VK_KHR_pipeline_executable_properties ===
13190 
13191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13192     VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,
13193                                                                     uint32_t *                                              pExecutableCount,
13194                                                                     VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
13195                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13196 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13197     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
13198               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13199     VULKAN_HPP_NODISCARD
13200       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
13201       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
13202                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13203     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
13204               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13205               typename std::enable_if<
13206                 std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value,
13207                 int>::type = 0>
13208     VULKAN_HPP_NODISCARD
13209       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
13210       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
13211                                           PipelineExecutablePropertiesKHRAllocator &    pipelineExecutablePropertiesKHRAllocator,
13212                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13213 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13214 
13215     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13216     VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
13217                                                                     uint32_t *                                              pStatisticCount,
13218                                                                     VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
13219                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13220 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13221     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
13222               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13223     VULKAN_HPP_NODISCARD
13224       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
13225       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
13226                                           Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13227     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
13228               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13229               typename std::enable_if<
13230                 std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value,
13231                 int>::type = 0>
13232     VULKAN_HPP_NODISCARD
13233       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
13234       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
13235                                           PipelineExecutableStatisticKHRAllocator &               pipelineExecutableStatisticKHRAllocator,
13236                                           Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13237 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13238 
13239     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13240     VULKAN_HPP_NODISCARD Result
13241       getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
13242                                                        uint32_t *                                                          pInternalRepresentationCount,
13243                                                        VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
13244                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13245 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13246     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
13247               typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13248     VULKAN_HPP_NODISCARD typename ResultValueType<
13249       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
13250       getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
13251                                                        Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13252     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
13253               typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13254               typename std::enable_if<std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type,
13255                                                    VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value,
13256                                       int>::type                            = 0>
13257     VULKAN_HPP_NODISCARD typename ResultValueType<
13258       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
13259       getPipelineExecutableInternalRepresentationsKHR(
13260         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
13261         PipelineExecutableInternalRepresentationKHRAllocator &  pipelineExecutableInternalRepresentationKHRAllocator,
13262         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13263 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13264 
13265     //=== VK_EXT_host_image_copy ===
13266 
13267     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13268     VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT * pCopyMemoryToImageInfo,
13269                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13271     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13272     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13273       copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT & copyMemoryToImageInfo,
13274                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13275 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13276 
13277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13278     VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT * pCopyImageToMemoryInfo,
13279                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13280 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13281     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13282     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13283       copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT & copyImageToMemoryInfo,
13284                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13285 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13286 
13287     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13288     VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT * pCopyImageToImageInfo,
13289                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13290 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13291     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13292     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13293       copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT & copyImageToImageInfo,
13294                            Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13295 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13296 
13297     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13298     VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t                                                       transitionCount,
13299                                                           const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT * pTransitions,
13300                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13301 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13303     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13304       transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> const & transitions,
13305                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13306 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13307 
13308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13309     void getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,
13310                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource,
13311                                         VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR *      pLayout,
13312                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13313 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13314     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13315     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
13316                          getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,
13317                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
13318                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13319     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13320     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13321                          getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                        image,
13322                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
13323                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13324 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13325 
13326     //=== VK_KHR_map_memory2 ===
13327 
13328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13329     VULKAN_HPP_NODISCARD Result mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR * pMemoryMapInfo,
13330                                                void **                                        ppData,
13331                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13332 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13333     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13334     VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo,
13335                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13336 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13337 
13338     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13339     VULKAN_HPP_NODISCARD Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo,
13340                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13341 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13342     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13343     typename ResultValueType<void>::type unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo,
13344                                                           Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13345 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13346 
13347     //=== VK_EXT_swapchain_maintenance1 ===
13348 
13349     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13350     VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT * pReleaseInfo,
13351                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13353     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13354     typename ResultValueType<void>::type releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo,
13355                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13356 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13357 
13358     //=== VK_NV_device_generated_commands ===
13359 
13360     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13361     void getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
13362                                                    VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
13363                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13364 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13365     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13366     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
13367                          getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
13368                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13369     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13370     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13371                          getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
13372                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13373 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13374 
13375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13376     VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
13377                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
13378                                                                 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *                 pIndirectCommandsLayout,
13379                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13380 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13381     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13382     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type
13383       createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,
13384                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13385                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13386 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13387     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13388     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type
13389       createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,
13390                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13391                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13392 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13393 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13394 
13395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13396     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
13397                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13398                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13399 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13400     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13401     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13402                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13403                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13404 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13405 
13406     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13407     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
13408                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13409                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13411     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13412     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV                      indirectCommandsLayout,
13413                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13414                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13415 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13416 
13417     //=== VK_EXT_private_data ===
13418 
13419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13420     VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,
13421                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
13422                                                           VULKAN_HPP_NAMESPACE::PrivateDataSlot *                 pPrivateDataSlot,
13423                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13424 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13425     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13426     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type
13427       createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
13428                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13429                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13430 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13431     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13432     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type
13433       createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
13434                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13435                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13436 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13437 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13438 
13439     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13440     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,
13441                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13442                                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13443 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13444     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13445     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13446                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13447                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13448 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13449 
13450 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13451     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13452     VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
13453                                                    uint64_t                              objectHandle,
13454                                                    VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
13455                                                    uint64_t                              data,
13456                                                    Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13457 #else
13458     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13459     typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
13460                                                             uint64_t                              objectHandle,
13461                                                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
13462                                                             uint64_t                              data,
13463                                                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13464 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13465 
13466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13467     void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
13468                             uint64_t                              objectHandle,
13469                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
13470                             uint64_t *                            pData,
13471                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13472 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13473     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13474     VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
13475                                                      uint64_t                              objectHandle,
13476                                                      VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
13477                                                      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13478 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13479 
13480     //=== VK_KHR_video_encode_queue ===
13481 
13482     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13483     VULKAN_HPP_NODISCARD Result
13484       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
13485                                            VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR *  pFeedbackInfo,
13486                                            size_t *                                                             pDataSize,
13487                                            void *                                                               pData,
13488                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13489 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13490     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13491     VULKAN_HPP_NODISCARD
13492       typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
13493       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
13494                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13495     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
13496               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13497               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
13498     VULKAN_HPP_NODISCARD
13499       typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
13500       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
13501                                            Uint8_tAllocator &                                                   uint8_tAllocator,
13502                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13503     template <typename X,
13504               typename Y,
13505               typename... Z,
13506               typename Uint8_tAllocator = std::allocator<uint8_t>,
13507               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13508     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
13509       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
13510                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13511     template <typename X,
13512               typename Y,
13513               typename... Z,
13514               typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
13515               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13516               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
13517     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
13518       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
13519                                            Uint8_tAllocator &                                                   uint8_tAllocator,
13520                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13521 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13522 
13523 #if defined( VK_ENABLE_BETA_EXTENSIONS )
13524     //=== VK_NV_cuda_kernel_launch ===
13525 
13526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13527     VULKAN_HPP_NODISCARD Result createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV * pCreateInfo,
13528                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
13529                                                     VULKAN_HPP_NAMESPACE::CudaModuleNV *                 pModule,
13530                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13531 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13532     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13533     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaModuleNV>::type
13534       createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV &                createInfo,
13535                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13536                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13537 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13538     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13539     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaModuleNV, Dispatch>>::type
13540       createCudaModuleNVUnique( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV &                createInfo,
13541                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13542                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13543 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
13544 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13545 
13546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13547     VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module,
13548                                                       size_t *                           pCacheSize,
13549                                                       void *                             pCacheData,
13550                                                       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13551 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13552     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13553     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
13554       getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13555     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
13556               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13557               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
13558     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getCudaModuleCacheNV(
13559       VULKAN_HPP_NAMESPACE::CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13560 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13561 
13562     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13563     VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV * pCreateInfo,
13564                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
13565                                                       VULKAN_HPP_NAMESPACE::CudaFunctionNV *                 pFunction,
13566                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13567 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13568     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13569     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>::type
13570       createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV &              createInfo,
13571                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13572                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13573 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13574     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13575     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaFunctionNV, Dispatch>>::type
13576       createCudaFunctionNVUnique( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV &              createInfo,
13577                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13578                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13579 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
13580 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13581 
13582     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13583     void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV                module,
13584                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13585                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13586 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13587     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13588     void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV                                  module,
13589                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13590                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13591 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13592 
13593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13594     void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV                module,
13595                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13596                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13597 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13599     void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV                                  module,
13600                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13601                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13602 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13603 
13604     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13605     void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV              function,
13606                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13607                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13608 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13609     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13610     void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV                                function,
13611                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13612                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13613 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13614 
13615     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13616     void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV              function,
13617                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13618                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13619 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13620     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13621     void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV                                function,
13622                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13623                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13624 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13625 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
13626 
13627 #if defined( VK_USE_PLATFORM_METAL_EXT )
13628     //=== VK_EXT_metal_objects ===
13629 
13630     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13631     void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo,
13632                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13633 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13634     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13635     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT
13636                          exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13637     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13638     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13639                          exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13640 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13641 #endif   /*VK_USE_PLATFORM_METAL_EXT*/
13642 
13643     //=== VK_EXT_descriptor_buffer ===
13644 
13645     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13646     void getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13647                                         VULKAN_HPP_NAMESPACE::DeviceSize *        pLayoutSizeInBytes,
13648                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13649 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13650     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13651     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
13652                          getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13653                                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13654 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13655 
13656     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13657     void getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13658                                                  uint32_t                                  binding,
13659                                                  VULKAN_HPP_NAMESPACE::DeviceSize *        pOffset,
13660                                                  Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13661 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13662     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13663     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
13664                          getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13665                                                                  uint32_t                                  binding,
13666                                                                  Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13667 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13668 
13669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13670     void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo,
13671                            size_t                                             dataSize,
13672                            void *                                             pDescriptor,
13673                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13674 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13676     void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
13677                            size_t                                             dataSize,
13678                            void *                                             pDescriptor,
13679                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13680     template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13681     VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
13682                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13683 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13684 
13685     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13686     VULKAN_HPP_NODISCARD Result
13687       getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo,
13688                                                void *                                                           pData,
13689                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13690 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13691     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13692     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13693       getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info,
13694                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13695 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13696 
13697     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13698     VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo,
13699                                                                         void *                                                          pData,
13700                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13702     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13703     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13704       getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info,
13705                                               Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13706 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13707 
13708     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13709     VULKAN_HPP_NODISCARD Result
13710       getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo,
13711                                                   void *                                                              pData,
13712                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13713 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13714     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13715     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13716       getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info,
13717                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13718 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13719 
13720     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13721     VULKAN_HPP_NODISCARD Result
13722       getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo,
13723                                                 void *                                                            pData,
13724                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13725 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13726     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13727     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13728       getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info,
13729                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13731 
13732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13733     VULKAN_HPP_NODISCARD Result
13734       getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
13735                                                               void *                                                                          pData,
13736                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13737 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13738     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13739     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13740       getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info,
13741                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13742 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13743 
13744     //=== VK_EXT_device_fault ===
13745 
13746     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13747     VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts,
13748                                                  VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT *   pFaultInfo,
13749                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13750 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13751     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13752     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>::type
13753       getFaultInfoEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13754 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13755 
13756 #if defined( VK_USE_PLATFORM_FUCHSIA )
13757     //=== VK_FUCHSIA_external_memory ===
13758 
13759     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13760     VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
13761                                                               zx_handle_t *                                                  pZirconHandle,
13762                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13763 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13764     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13765     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
13766       getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
13767                                     Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13768 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13769 
13770     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13771     VULKAN_HPP_NODISCARD Result
13772       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
13773                                               zx_handle_t                                                 zirconHandle,
13774                                               VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
13775                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13776 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13777     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13778     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
13779       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
13780                                               zx_handle_t                                            zirconHandle,
13781                                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13782 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13783 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
13784 
13785 #if defined( VK_USE_PLATFORM_FUCHSIA )
13786     //=== VK_FUCHSIA_external_semaphore ===
13787 
13788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13789     VULKAN_HPP_NODISCARD Result
13790       importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
13791                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13792 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13793     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13794     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13795       importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
13796                                           Dispatch const & d                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13797 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13798 
13799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13800     VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
13801                                                                  zx_handle_t *                                                     pZirconHandle,
13802                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13803 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13804     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13805     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
13806       getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
13807                                        Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13808 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13809 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
13810 
13811 #if defined( VK_USE_PLATFORM_FUCHSIA )
13812     //=== VK_FUCHSIA_buffer_collection ===
13813 
13814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13815     VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
13816                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
13817                                                                VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA *                 pCollection,
13818                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13819 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13820     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13821     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type
13822       createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,
13823                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13824                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13825 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13826     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13827     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type
13828       createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,
13829                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13830                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13831 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
13832 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13833 
13834     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13835     VULKAN_HPP_NODISCARD Result
13836       setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
13837                                                   const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
13838                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13839 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13840     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13841     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13842       setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
13843                                                   const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,
13844                                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13845 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13846 
13847     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13848     VULKAN_HPP_NODISCARD Result
13849       setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
13850                                                    const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,
13851                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13852 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13853     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13854     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13855       setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
13856                                                    const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,
13857                                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13858 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13859 
13860     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13861     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
13862                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13863                                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13864 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13865     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13866     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,
13867                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13868                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13869 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13870 
13871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13872     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
13873                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13874                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13875 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13876     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13877     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,
13878                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13879                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13880 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13881 
13882     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13883     VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
13884                                                                       VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties,
13885                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13886 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13887     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13888     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type
13889       getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13890                                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13891 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13892 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
13893 
13894     //=== VK_HUAWEI_subpass_shading ===
13895 
13896     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13897     VULKAN_HPP_NODISCARD Result
13898       getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,
13899                                                VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,
13900                                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13901 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13902     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13903     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Extent2D>::type
13904       getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13905 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13906 
13907     //=== VK_NV_external_memory_rdma ===
13908 
13909     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13910     VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
13911                                                           VULKAN_HPP_NAMESPACE::RemoteAddressNV *                    pAddress,
13912                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13913 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13915     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type
13916       getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,
13917                                 Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13918 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13919 
13920     //=== VK_EXT_pipeline_properties ===
13921 
13922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13923     VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT * pPipelineInfo,
13924                                                           VULKAN_HPP_NAMESPACE::BaseOutStructure *      pPipelineProperties,
13925                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13926 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13928     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BaseOutStructure>::type
13929       getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13930 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13931 
13932     //=== VK_EXT_opacity_micromap ===
13933 
13934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13935     VULKAN_HPP_NODISCARD Result createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo,
13936                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
13937                                                    VULKAN_HPP_NAMESPACE::MicromapEXT *                 pMicromap,
13938                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13939 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13940     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13941     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MicromapEXT>::type
13942       createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,
13943                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13944                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13945 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13946     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13947     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>>::type
13948       createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,
13949                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13950                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13951 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13952 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13953 
13954     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13955     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,
13956                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13957                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13958 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13959     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13960     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap                          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13961                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13962                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13963 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13964 
13965     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13966     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,
13967                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13968                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13969 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13970     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13971     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                                   micromap,
13972                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13973                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13974 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13975 
13976     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13977     VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR         deferredOperation,
13978                                                    uint32_t                                           infoCount,
13979                                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,
13980                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13981 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13982     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13983     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
13984                          buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                 deferredOperation,
13985                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,
13986                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13987 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13988 
13989     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13990     VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,
13991                                                  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,
13992                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13993 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13994     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13995     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,
13996                                                                        const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,
13997                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13998 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13999 
14000     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14001     VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
14002                                                          const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,
14003                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14004 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14005     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14006     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
14007                                                                                const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,
14008                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14009 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14010 
14011     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14012     VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
14013                                                          const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,
14014                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14015 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14016     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14017     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
14018                                                                                const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,
14019                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14020 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14021 
14022     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14023     VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,
14024                                                              const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
14025                                                              VULKAN_HPP_NAMESPACE::QueryType           queryType,
14026                                                              size_t                                    dataSize,
14027                                                              void *                                    pData,
14028                                                              size_t                                    stride,
14029                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14030 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14031     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14032     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
14033       writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
14034                                    VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,
14035                                    size_t                                                                            dataSize,
14036                                    size_t                                                                            stride,
14037                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14038     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14039     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
14040       writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
14041                                  VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,
14042                                  size_t                                                                            stride,
14043                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14044 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14045 
14046     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14047     void getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT *          pVersionInfo,
14048                                       VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility,
14049                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14050 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14051     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14052     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
14053                          getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo,
14054                                                       Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14055 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14056 
14057     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14058     void getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
14059                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *      pBuildInfo,
14060                                    VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT *       pSizeInfo,
14061                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14062 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14063     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14064     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT
14065                          getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
14066                                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT &      buildInfo,
14067                                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14068 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14069 
14070     //=== VK_EXT_pageable_device_local_memory ===
14071 
14072     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14073     void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
14074                                float                              priority,
14075                                Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14076 
14077     //=== VK_KHR_maintenance4 ===
14078 
14079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14080     void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,
14081                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                  pMemoryRequirements,
14082                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14083 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14084     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14085     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
14086                          getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
14087                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14088     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14089     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14090                          getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
14091                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14092 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14093 
14094     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14095     void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
14096                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
14097                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14098 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14100     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
14101                          getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
14102                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14103     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14104     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14105                          getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
14106                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14107 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14108 
14109     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14110     void getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
14111                                               uint32_t *                                                  pSparseMemoryRequirementCount,
14112                                               VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *      pSparseMemoryRequirements,
14113                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14115     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
14116               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14117     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
14118                          getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
14119                                                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14120     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
14121               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14122               typename std::enable_if<
14123                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
14124                 int>::type = 0>
14125     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
14126                          getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
14127                                                               SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
14128                                                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14129 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14130 
14131     //=== VK_VALVE_descriptor_set_host_mapping ===
14132 
14133     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14134     void getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference,
14135                                                      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE *  pHostMapping,
14136                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14137 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14138     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14139     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE
14140                          getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference,
14141                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14142 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14143 
14144     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14145     void getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
14146                                            void **                             ppData,
14147                                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14148 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14149     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14150     VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
14151                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14152 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14153 
14154     //=== VK_NV_device_generated_commands_compute ===
14155 
14156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14157     void getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfo,
14158                                                   VULKAN_HPP_NAMESPACE::MemoryRequirements2 *             pMemoryRequirements,
14159                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14160 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14161     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14162     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
14163                          getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
14164                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14165     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14166     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14167                          getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
14168                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14169 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14170 
14171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14172     DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV * pInfo,
14173                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14174 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14175     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14176     VULKAN_HPP_NAMESPACE::DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info,
14177                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14178 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14179 
14180     //=== VK_EXT_shader_module_identifier ===
14181 
14182     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14183     void getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
14184                                        VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier,
14185                                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14186 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14187     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14188     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
14189                          getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
14190                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14191 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14192 
14193     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14194     void getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
14195                                                  VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT *    pIdentifier,
14196                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14197 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14198     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14199     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
14200                          getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
14201                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14202 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14203 
14204     //=== VK_NV_optical_flow ===
14205 
14206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14207     VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo,
14208                                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
14209                                                             VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV *                 pSession,
14210                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14211 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14212     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14213     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>::type
14214       createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,
14215                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14216                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14217 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14218     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14219     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>>::type
14220       createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,
14221                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14222                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14223 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
14224 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14225 
14226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14227     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,
14228                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14229                                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14230 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14231     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14232     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,
14233                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14234                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14235 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14236 
14237     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14238     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,
14239                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14240                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14241 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14242     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14243     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,
14244                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14245                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14246 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14247 
14248 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14249     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14250     VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
14251                                                                VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
14252                                                                VULKAN_HPP_NAMESPACE::ImageView                        view,
14253                                                                VULKAN_HPP_NAMESPACE::ImageLayout                      layout,
14254                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14255 #else
14256     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14257     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14258          bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
14259                                         VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
14260                                         VULKAN_HPP_NAMESPACE::ImageView                        view,
14261                                         VULKAN_HPP_NAMESPACE::ImageLayout                      layout,
14262                                         Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14263 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14264 
14265     //=== VK_KHR_maintenance5 ===
14266 
14267     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14268     void getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR * pRenderingAreaInfo,
14269                                          VULKAN_HPP_NAMESPACE::Extent2D *                   pGranularity,
14270                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14271 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14272     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14273     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
14274                          getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR & renderingAreaInfo,
14275                                                          Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14276 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14277 
14278     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14279     void getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR * pInfo,
14280                                        VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR *               pLayout,
14281                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14282 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14283     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14284     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
14285                          getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info,
14286                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14287     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14288     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14289                          getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info,
14290                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14291 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14292 
14293     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14294     void getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                        image,
14295                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource,
14296                                         VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR *      pLayout,
14297                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14298 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14299     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14300     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
14301                          getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                        image,
14302                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
14303                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14304     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14305     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14306                          getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                        image,
14307                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
14308                                                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14309 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14310 
14311     //=== VK_EXT_shader_object ===
14312 
14313     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14314     VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t                                          createInfoCount,
14315                                                   const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos,
14316                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14317                                                   VULKAN_HPP_NAMESPACE::ShaderEXT *                 pShaders,
14318                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14319 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14320     template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14321     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>
14322                          createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
14323                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14324                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14325     template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>,
14326               typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14327               typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type = 0>
14328     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>
14329                          createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
14330                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,
14331                                            ShaderEXTAllocator &                                                                      shaderEXTAllocator,
14332                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14333     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14334     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::ShaderEXT>
14335                          createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT &                   createInfo,
14336                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14337                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14338 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14339     template <typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14340               typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>>
14341     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>
14342                          createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
14343                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14344                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14345     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14346               typename ShaderEXTAllocator        = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>,
14347               typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value,
14348                                       int>::type = 0>
14349     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>
14350                          createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
14351                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,
14352                                                  ShaderEXTAllocator &                                                                      shaderEXTAllocator,
14353                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14354     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14355     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>
14356                          createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT &                   createInfo,
14357                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14358                                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14359 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
14360 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14361 
14362     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14363     void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT                   shader,
14364                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14365                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14368     void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader                              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14369                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14370                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14371 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14372 
14373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14374     void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT                   shader,
14375                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14376                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14377 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14378     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14379     void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT                                     shader,
14380                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14381                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14382 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14383 
14384     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14385     VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader,
14386                                                         size_t *                        pDataSize,
14387                                                         void *                          pData,
14388                                                         Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14389 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14390     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14391     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
14392       getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14393     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
14394               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14395               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
14396     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderBinaryDataEXT(
14397       VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14398 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14399 
14400     //=== VK_QCOM_tile_properties ===
14401 
14402     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14403     VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer          framebuffer,
14404                                                                   uint32_t *                                 pPropertiesCount,
14405                                                                   VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties,
14406                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14407 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14408     template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
14409               typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14410     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
14411       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14412     template <
14413       typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
14414       typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14415       typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type = 0>
14416     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
14417       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
14418                                         TilePropertiesQCOMAllocator &     tilePropertiesQCOMAllocator,
14419                                         Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14420 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14421 
14422     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14423     Result getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
14424                                                   VULKAN_HPP_NAMESPACE::TilePropertiesQCOM *  pProperties,
14425                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14426 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14427     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14428     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM
14429                          getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
14430                                                                 Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14431 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14432 
14433     //=== VK_NV_low_latency2 ===
14434 
14435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14436     VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
14437                                                        const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo,
14438                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14439 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14440     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14441     typename ResultValueType<void>::type setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
14442                                                                 const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo,
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     Result latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR               swapchain,
14448                            const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo,
14449                            Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14451     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14452     void latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR               swapchain,
14453                          const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo,
14454                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14455 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14456 
14457     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14458     void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
14459                              const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
14460                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14461 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14462     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14463     void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
14464                              const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo,
14465                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14466 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14467 
14468     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14469     void getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR             swapchain,
14470                               VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
14471                               Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14472 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14473     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14474     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV
14475                          getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
14476                                               Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14477 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14478 
14479 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
14480     //=== VK_QNX_external_memory_screen_buffer ===
14481 
14482     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14483     VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer *                     buffer,
14484                                                               VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX * pProperties,
14485                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14486 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14487     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14488     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>::type
14489       getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14490     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14491     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14492       getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14493 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14494 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
14495 
14496     //=== VK_KHR_calibrated_timestamps ===
14497 
14498     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14499     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t                                                 timestampCount,
14500                                                             const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
14501                                                             uint64_t *                                               pTimestamps,
14502                                                             uint64_t *                                               pMaxDeviation,
14503                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14504 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14505     template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14506     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
14507       getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
14508                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14509     template <typename Uint64_tAllocator                                                                                = std::allocator<uint64_t>,
14510               typename Dispatch                                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14511               typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
14512     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
14513       getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
14514                                   Uint64_tAllocator &                                                                              uint64_tAllocator,
14515                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14517     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
14518       getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
14519                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14520 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14521 
operator VkDevice() const14522     operator VkDevice() const VULKAN_HPP_NOEXCEPT
14523     {
14524       return m_device;
14525     }
14526 
operator bool() const14527     explicit operator bool() const VULKAN_HPP_NOEXCEPT
14528     {
14529       return m_device != VK_NULL_HANDLE;
14530     }
14531 
operator !() const14532     bool operator!() const VULKAN_HPP_NOEXCEPT
14533     {
14534       return m_device == VK_NULL_HANDLE;
14535     }
14536 
14537   private:
14538     VkDevice m_device = {};
14539   };
14540 
14541   template <>
14542   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
14543   {
14544     using Type = VULKAN_HPP_NAMESPACE::Device;
14545   };
14546 
14547   template <>
14548   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
14549   {
14550     using Type = VULKAN_HPP_NAMESPACE::Device;
14551   };
14552 
14553 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
14554   template <>
14555   struct CppType<VkDevice, VK_NULL_HANDLE>
14556   {
14557     using Type = VULKAN_HPP_NAMESPACE::Device;
14558   };
14559 #endif
14560 
14561   template <>
14562   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
14563   {
14564     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
14565   };
14566 
14567   class DisplayModeKHR
14568   {
14569   public:
14570     using CType      = VkDisplayModeKHR;
14571     using NativeType = VkDisplayModeKHR;
14572 
14573     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
14574     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
14575       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
14576 
14577   public:
14578     DisplayModeKHR()                                         = default;
14579     DisplayModeKHR( DisplayModeKHR const & rhs )             = default;
14580     DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default;
14581     DisplayModeKHR( DisplayModeKHR && rhs )                  = default;
14582     DisplayModeKHR & operator=( DisplayModeKHR && rhs )      = default;
14583 
DisplayModeKHR(std::nullptr_t)14584     VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
14585 
DisplayModeKHR(VkDisplayModeKHR displayModeKHR)14586     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}
14587 
14588 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDisplayModeKHR displayModeKHR)14589     DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
14590     {
14591       m_displayModeKHR = displayModeKHR;
14592       return *this;
14593     }
14594 #endif
14595 
operator =(std::nullptr_t)14596     DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
14597     {
14598       m_displayModeKHR = {};
14599       return *this;
14600     }
14601 
14602 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
14603     auto operator<=>( DisplayModeKHR const & ) const = default;
14604 #else
operator ==(DisplayModeKHR const & rhs) const14605     bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
14606     {
14607       return m_displayModeKHR == rhs.m_displayModeKHR;
14608     }
14609 
operator !=(DisplayModeKHR const & rhs) const14610     bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
14611     {
14612       return m_displayModeKHR != rhs.m_displayModeKHR;
14613     }
14614 
operator <(DisplayModeKHR const & rhs) const14615     bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
14616     {
14617       return m_displayModeKHR < rhs.m_displayModeKHR;
14618     }
14619 #endif
14620 
operator VkDisplayModeKHR() const14621     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
14622     {
14623       return m_displayModeKHR;
14624     }
14625 
operator bool() const14626     explicit operator bool() const VULKAN_HPP_NOEXCEPT
14627     {
14628       return m_displayModeKHR != VK_NULL_HANDLE;
14629     }
14630 
operator !() const14631     bool operator!() const VULKAN_HPP_NOEXCEPT
14632     {
14633       return m_displayModeKHR == VK_NULL_HANDLE;
14634     }
14635 
14636   private:
14637     VkDisplayModeKHR m_displayModeKHR = {};
14638   };
14639 
14640   template <>
14641   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
14642   {
14643     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
14644   };
14645 
14646   template <>
14647   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
14648   {
14649     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
14650   };
14651 
14652 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
14653   template <>
14654   struct CppType<VkDisplayModeKHR, VK_NULL_HANDLE>
14655   {
14656     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
14657   };
14658 #endif
14659 
14660   template <>
14661   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
14662   {
14663     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
14664   };
14665 
14666   class PhysicalDevice
14667   {
14668   public:
14669     using CType      = VkPhysicalDevice;
14670     using NativeType = VkPhysicalDevice;
14671 
14672     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
14673     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
14674       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
14675 
14676   public:
14677     PhysicalDevice()                                         = default;
14678     PhysicalDevice( PhysicalDevice const & rhs )             = default;
14679     PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default;
14680     PhysicalDevice( PhysicalDevice && rhs )                  = default;
14681     PhysicalDevice & operator=( PhysicalDevice && rhs )      = default;
14682 
PhysicalDevice(std::nullptr_t)14683     VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
14684 
PhysicalDevice(VkPhysicalDevice physicalDevice)14685     PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}
14686 
operator =(VkPhysicalDevice physicalDevice)14687     PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
14688     {
14689       m_physicalDevice = physicalDevice;
14690       return *this;
14691     }
14692 
operator =(std::nullptr_t)14693     PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
14694     {
14695       m_physicalDevice = {};
14696       return *this;
14697     }
14698 
14699 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
14700     auto operator<=>( PhysicalDevice const & ) const = default;
14701 #else
operator ==(PhysicalDevice const & rhs) const14702     bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
14703     {
14704       return m_physicalDevice == rhs.m_physicalDevice;
14705     }
14706 
operator !=(PhysicalDevice const & rhs) const14707     bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
14708     {
14709       return m_physicalDevice != rhs.m_physicalDevice;
14710     }
14711 
operator <(PhysicalDevice const & rhs) const14712     bool operator<( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
14713     {
14714       return m_physicalDevice < rhs.m_physicalDevice;
14715     }
14716 #endif
14717 
14718     //=== VK_VERSION_1_0 ===
14719 
14720     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14721     void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
14722                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14723 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14725     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
14726                          getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14727 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14728 
14729     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14730     void getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
14731                               VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
14732                               Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14733 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14734     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14735     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
14736       getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14737 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14738 
14739     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14740     VULKAN_HPP_NODISCARD Result getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
14741                                                           VULKAN_HPP_NAMESPACE::ImageType               type,
14742                                                           VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
14743                                                           VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
14744                                                           VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
14745                                                           VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
14746                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14747 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14749     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
14750       getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                 format,
14751                                 VULKAN_HPP_NAMESPACE::ImageType              type,
14752                                 VULKAN_HPP_NAMESPACE::ImageTiling            tiling,
14753                                 VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,
14754                                 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14755                                 Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14756 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14757 
14758     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14759     void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
14760                         Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14761 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14762     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14763     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
14764                          getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14765 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14766 
14767     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14768     void getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
14769                                    VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
14770                                    Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14771 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14772     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
14773               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14774     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
14775                          getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14776     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
14777               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14778               typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value,
14779                                       int>::type      = 0>
14780     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
14781                          getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
14782                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14783 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14784 
14785     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14786     void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
14787                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14788 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14789     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14790     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
14791                          getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14792 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14793 
14794     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14795     VULKAN_HPP_NODISCARD Result createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *    pCreateInfo,
14796                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14797                                               VULKAN_HPP_NAMESPACE::Device *                    pDevice,
14798                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14800     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14801     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
14802       createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &                      createInfo,
14803                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14804                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14805 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14806     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14807     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
14808       createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &                      createInfo,
14809                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14810                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14811 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
14812 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14813 
14814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14815     VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char *                                pLayerName,
14816                                                                     uint32_t *                                  pPropertyCount,
14817                                                                     VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
14818                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14819 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14820     template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
14821               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14822     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
14823       enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14824                                           Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14825     template <
14826       typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
14827       typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14828       typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
14829     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
14830       enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
14831                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
14832                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14833 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14834 
14835     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14836     VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t *                              pPropertyCount,
14837                                                                 VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
14838                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14839 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14840     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14841     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
14842       enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14843     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
14844               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14845               typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
14846     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
14847       enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14848 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14849 
14850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14851     void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
14852                                          VULKAN_HPP_NAMESPACE::ImageType                     type,
14853                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
14854                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
14855                                          VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
14856                                          uint32_t *                                          pPropertyCount,
14857                                          VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
14858                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14859 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14860     template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
14861               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14862     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
14863                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
14864                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
14865                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
14866                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
14867                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
14868                                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14869     template <
14870       typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
14871       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14872       typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value,
14873                               int>::type            = 0>
14874     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
14875                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
14876                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
14877                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
14878                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
14879                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
14880                                                          SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
14881                                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14882 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14883 
14884     //=== VK_VERSION_1_1 ===
14885 
14886     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14887     void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
14888                        Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14889 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14890     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14891     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
14892                          getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14893     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14894     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14895                          getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14896 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14897 
14898     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14899     void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
14900                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14901 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14902     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14903     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
14904                          getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14905     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14906     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14907                          getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14908 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14909 
14910     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14911     void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
14912                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
14913                                Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14914 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14915     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14916     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
14917       getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14918     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14919     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14920       getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14921 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14922 
14923     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14924     VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
14925                                                            VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
14926                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14927 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14928     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14929     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
14930       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14931                                  Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14932     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14933     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14934       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14935                                  Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14936 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14937 
14938     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14939     void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
14940                                     VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
14941                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14942 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14943     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14944               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14945     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14946                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14947     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14948               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14949               typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,
14950                                       int>::type       = 0>
14951     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14952                          getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
14953                                                     Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14954     template <typename StructureChain,
14955               typename StructureChainAllocator = std::allocator<StructureChain>,
14956               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14957     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14958                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14959     template <typename StructureChain,
14960               typename StructureChainAllocator = std::allocator<StructureChain>,
14961               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14962               typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
14963     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14964       getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14965 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14966 
14967     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14968     void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
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 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
14973                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14974     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14975     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14976                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14977 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14978 
14979     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14980     void getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
14981                                           uint32_t *                                                         pPropertyCount,
14982                                           VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
14983                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14984 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14985     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14986               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14987     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14988                          getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14989                                                           Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14990     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14991               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14992               typename std::enable_if<
14993                 std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
14994                 int>::type = 0>
14995     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14996                          getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14997                                                           SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,
14998                                                           Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14999 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15000 
15001     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15002     void getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
15003                                       VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
15004                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15005 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15007     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
15008                          getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
15009                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15010 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15011 
15012     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15013     void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
15014                                      VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
15015                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15016 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15018     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
15019                          getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
15020                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15021 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15022 
15023     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15024     void getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
15025                                          VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
15026                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15028     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15029     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
15030                          getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
15031                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15032 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15033 
15034     //=== VK_VERSION_1_3 ===
15035 
15036     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15037     VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t *                                           pToolCount,
15038                                                    VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,
15039                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15040 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15041     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
15042               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15043     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
15044       getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15045     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
15046               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15047               typename std::enable_if<
15048                 std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
15049                 int>::type = 0>
15050     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
15051       getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
15052                          Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15054 
15055     //=== VK_KHR_surface ===
15056 
15057     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15058     VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
15059                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
15060                                                       VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
15061                                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15062 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15063     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15064     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type getSurfaceSupportKHR(
15065       uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15066 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15067 
15068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15069     VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
15070                                                            VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
15071                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15072 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15074     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
15075       getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15076 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15077 
15078     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15079     VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
15080                                                       uint32_t *                               pSurfaceFormatCount,
15081                                                       VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
15082                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15083 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15084     template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
15085               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15086     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
15087       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15088                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15089     template <
15090       typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
15091       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15092       typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type = 0>
15093     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
15094       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
15095                             SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
15096                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15097 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15098 
15099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15100     VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
15101                                                            uint32_t *                             pPresentModeCount,
15102                                                            VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
15103                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15104 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15105     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15106     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
15107       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15108                                  Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15109     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
15110               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15111               typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
15112     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
15113       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
15114                                  PresentModeKHRAllocator &        presentModeKHRAllocator,
15115                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15116 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15117 
15118     //=== VK_KHR_swapchain ===
15119 
15120     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15121     VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
15122                                                          uint32_t *                       pRectCount,
15123                                                          VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
15124                                                          Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15126     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15127     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type
15128       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15129     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>,
15130               typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15131               typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type = 0>
15132     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR(
15133       VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15134 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15135 
15136     //=== VK_KHR_display ===
15137 
15138     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15139     VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
15140                                                          VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
15141                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15142 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15143     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
15144               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15145     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
15146       getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15147     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
15148               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15149               typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value,
15150                                       int>::type     = 0>
15151     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
15152       getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
15153                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15154 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15155 
15156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15157     VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t *                                        pPropertyCount,
15158                                                               VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
15159                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15160 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15161     template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
15162               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15163     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
15164       getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15165     template <
15166       typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
15167       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15168       typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value,
15169                               int>::type          = 0>
15170     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
15171       getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
15172                                     Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15173 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15174 
15175     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15176     VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t                           planeIndex,
15177                                                                      uint32_t *                         pDisplayCount,
15178                                                                      VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
15179                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15180 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15181     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15182     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type
15183       getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15184     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>,
15185               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15186               typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type = 0>
15187     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR(
15188       uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15189 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15190 
15191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15192     VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
15193                                                              uint32_t *                                       pPropertyCount,
15194                                                              VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
15195                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15196 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15197     template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
15198               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15199     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
15200       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15201     template <
15202       typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
15203       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15204       typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value,
15205                               int>::type         = 0>
15206     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
15207       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
15208                                    DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
15209                                    Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15211 
15212     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15213     VULKAN_HPP_NODISCARD Result createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
15214                                                       const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
15215                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
15216                                                       VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
15217                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15218 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15219     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15220     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
15221       createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
15222                             const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &              createInfo,
15223                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15224                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15225 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
15226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15227     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
15228       createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
15229                                   const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &              createInfo,
15230                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15231                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15232 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15233 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15234 
15235     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15236     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
15237                                                                 uint32_t                                            planeIndex,
15238                                                                 VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
15239                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15240 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15241     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15242     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR(
15243       VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15245 
15246 #if defined( VK_USE_PLATFORM_XLIB_KHR )
15247     //=== VK_KHR_xlib_surface ===
15248 
15249     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15250     Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
15251                                           Display *          dpy,
15252                                           VisualID           visualID,
15253                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15254 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15255     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15256     VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
15257                                                                 Display &          dpy,
15258                                                                 VisualID           visualID,
15259                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15260 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15261 #endif   /*VK_USE_PLATFORM_XLIB_KHR*/
15262 
15263 #if defined( VK_USE_PLATFORM_XCB_KHR )
15264     //=== VK_KHR_xcb_surface ===
15265 
15266     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15267     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
15268                                          xcb_connection_t * connection,
15269                                          xcb_visualid_t     visual_id,
15270                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15271 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15272     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15273     VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
15274                                                                xcb_connection_t & connection,
15275                                                                xcb_visualid_t     visual_id,
15276                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15277 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15278 #endif   /*VK_USE_PLATFORM_XCB_KHR*/
15279 
15280 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
15281     //=== VK_KHR_wayland_surface ===
15282 
15283     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15284     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
15285                                              struct wl_display * display,
15286                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15287 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15288     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15289     VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
15290                                                                    struct wl_display & display,
15291                                                                    Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15292 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15293 #endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
15294 
15295 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15296     //=== VK_KHR_win32_surface ===
15297 
15298     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15299     Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15300 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15301 
15302     //=== VK_KHR_video_queue ===
15303 
15304     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15305     VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile,
15306                                                          VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *      pCapabilities,
15307                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15308 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15309     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15310     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
15311       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
15312                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15313     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15314     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
15315       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
15316                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15317 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15318 
15319     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15320     VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
15321                                                              uint32_t *                                                     pVideoFormatPropertyCount,
15322                                                              VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
15323                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15324 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15325     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
15326               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15327     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
15328       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
15329                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15330     template <
15331       typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
15332       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15333       typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value,
15334                               int>::type         = 0>
15335     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
15336       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
15337                                    VideoFormatPropertiesKHRAllocator &                            videoFormatPropertiesKHRAllocator,
15338                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15339 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15340 
15341     //=== VK_NV_external_memory_capabilities ===
15342 
15343     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15344     VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                            format,
15345                                                                     VULKAN_HPP_NAMESPACE::ImageType                         type,
15346                                                                     VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
15347                                                                     VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
15348                                                                     VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
15349                                                                     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
15350                                                                     VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
15351                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15353     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15354     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
15355       getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                                             format,
15356                                           VULKAN_HPP_NAMESPACE::ImageType                                          type,
15357                                           VULKAN_HPP_NAMESPACE::ImageTiling                                        tiling,
15358                                           VULKAN_HPP_NAMESPACE::ImageUsageFlags                                    usage,
15359                                           VULKAN_HPP_NAMESPACE::ImageCreateFlags flags                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15360                                           VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15361                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15363 
15364     //=== VK_KHR_get_physical_device_properties2 ===
15365 
15366     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15367     void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
15368                           Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15369 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15370     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15371     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
15372                          getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15373     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15374     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15375                          getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15376 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15377 
15378     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15379     void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
15380                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15381 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15382     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15383     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
15384                          getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15385     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15386     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15387                          getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15388 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15389 
15390     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15391     void getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
15392                                   VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
15393                                   Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15396     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
15397       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15398     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15399     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15400       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15401 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15402 
15403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15404     VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
15405                                                               VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
15406                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15407 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15408     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15409     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
15410       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
15411                                     Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15412     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15413     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
15414       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
15415                                     Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15416 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15417 
15418     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15419     void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,
15420                                        VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
15421                                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15422 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15423     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
15424               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15425     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
15426                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15427     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
15428               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15429               typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,
15430                                       int>::type       = 0>
15431     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
15432                          getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
15433                                                        Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15434     template <typename StructureChain,
15435               typename StructureChainAllocator = std::allocator<StructureChain>,
15436               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15437     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
15438                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15439     template <typename StructureChain,
15440               typename StructureChainAllocator = std::allocator<StructureChain>,
15441               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15442               typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
15443     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
15444       getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15446 
15447     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15448     void getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
15449                                   Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15451     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15452     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
15453                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15454     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15455     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15456                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15457 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15458 
15459     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15460     void getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
15461                                              uint32_t *                                                         pPropertyCount,
15462                                              VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
15463                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15464 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15465     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
15466               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15467     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
15468                          getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
15469                                                              Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15470     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
15471               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15472               typename std::enable_if<
15473                 std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
15474                 int>::type = 0>
15475     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
15476                          getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
15477                                                              SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,
15478                                                              Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15479 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15480 
15481     //=== VK_KHR_external_memory_capabilities ===
15482 
15483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15484     void getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
15485                                          VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
15486                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15487 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15488     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15489     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
15490                          getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
15491                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15492 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15493 
15494     //=== VK_KHR_external_semaphore_capabilities ===
15495 
15496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15497     void getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
15498                                             VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
15499                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15500 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15502     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
15503                          getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
15504                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15505 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15506 
15507     //=== VK_EXT_direct_mode_display ===
15508 
15509 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15510     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15511     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15512 #else
15513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15514     void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15515 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15516 
15517 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
15518     //=== VK_EXT_acquire_xlib_display ===
15519 
15520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15521     VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display *                        dpy,
15522                                                        VULKAN_HPP_NAMESPACE::DisplayKHR display,
15523                                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15524 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15526     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15527       acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15528 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15529 
15530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15531     VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display *                          dpy,
15532                                                           RROutput                           rrOutput,
15533                                                           VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
15534                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15535 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15536     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15537     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
15538       getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15539 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
15540     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15541     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
15542       getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15543 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15544 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15545 #endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
15546 
15547     //=== VK_EXT_display_surface_counter ===
15548 
15549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15550     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
15551                                                             VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
15552                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15553 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15554     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15555     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
15556       getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15557 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15558 
15559     //=== VK_KHR_external_fence_capabilities ===
15560 
15561     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15562     void getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
15563                                         VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
15564                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15565 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15566     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15567     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
15568                          getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
15569                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15571 
15572     //=== VK_KHR_performance_query ===
15573 
15574     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15575     VULKAN_HPP_NODISCARD Result
15576       enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t                                                 queueFamilyIndex,
15577                                                        uint32_t *                                               pCounterCount,
15578                                                        VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *            pCounters,
15579                                                        VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
15580                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15581 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15582     template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
15583               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
15584               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15585     VULKAN_HPP_NODISCARD
15586       typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
15587                                          std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
15588       enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15589     template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
15590               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
15591               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15592               typename std::enable_if<
15593                 std::is_same<typename PerformanceCounterKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value &&
15594                   std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value,
15595                 int>::type = 0>
15596     VULKAN_HPP_NODISCARD
15597       typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
15598                                          std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
15599       enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t                                    queueFamilyIndex,
15600                                                        PerformanceCounterKHRAllocator &            performanceCounterKHRAllocator,
15601                                                        PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
15602                                                        Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15603 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15604 
15605     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15606     void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
15607                                                   uint32_t *                                                      pNumPasses,
15608                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15609 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15610     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15611     VULKAN_HPP_NODISCARD uint32_t
15612       getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
15613                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15614 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15615 
15616     //=== VK_KHR_get_surface_capabilities2 ===
15617 
15618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15619     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
15620                                                             VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
15621                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15622 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15623     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15624     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
15625       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15626                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15627     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15628     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
15629       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15630                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15631 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15632 
15633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15634     VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
15635                                                        uint32_t *                                                  pSurfaceFormatCount,
15636                                                        VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *                   pSurfaceFormats,
15637                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15638 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15639     template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
15640               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15641     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
15642       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15643                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15644     template <
15645       typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
15646       typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15647       typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type = 0>
15648     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
15649       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15650                              SurfaceFormat2KHRAllocator &                                surfaceFormat2KHRAllocator,
15651                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15652     template <typename StructureChain,
15653               typename StructureChainAllocator = std::allocator<StructureChain>,
15654               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15655     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
15656       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15657                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15658     template <typename StructureChain,
15659               typename StructureChainAllocator = std::allocator<StructureChain>,
15660               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15661               typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
15662     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
15663       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15664                              StructureChainAllocator &                                   structureChainAllocator,
15665                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15666 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15667 
15668     //=== VK_KHR_get_display_properties2 ===
15669 
15670     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15671     VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
15672                                                           VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
15673                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15674 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15675     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
15676               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15677     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
15678       getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15679     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
15680               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15681               typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value,
15682                                       int>::type      = 0>
15683     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
15684       getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
15685                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15686 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15687 
15688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15689     VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t *                                         pPropertyCount,
15690                                                                VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
15691                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15692 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15693     template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
15694               typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15695     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
15696       getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15697     template <
15698       typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
15699       typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15700       typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value,
15701                               int>::type           = 0>
15702     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
15703       getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
15704                                      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15705 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15706 
15707     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15708     VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
15709                                                               uint32_t *                                        pPropertyCount,
15710                                                               VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
15711                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15713     template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
15714               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15715     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
15716       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15717     template <
15718       typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
15719       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15720       typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value,
15721                               int>::type          = 0>
15722     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
15723       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR     display,
15724                                     DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
15725                                     Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15726 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15727 
15728     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15729     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
15730                                                                  VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
15731                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15732 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15733     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15734     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type
15735       getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo,
15736                                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15737 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15738 
15739     //=== VK_EXT_sample_locations ===
15740 
15741     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15742     void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
15743                                       VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
15744                                       Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15745 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15746     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15747     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
15748                          getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
15749                                                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15750 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15751 
15752     //=== VK_EXT_calibrated_timestamps ===
15753 
15754     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15755     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t *                            pTimeDomainCount,
15756                                                                 VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
15757                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15758 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15759     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15760     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
15761       getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15762     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
15763               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15764               typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
15765     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
15766       getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15767 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15768 
15769     //=== VK_KHR_fragment_shading_rate ===
15770 
15771     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15772     VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t *                                                   pFragmentShadingRateCount,
15773                                                             VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
15774                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15776     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
15777               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15778     VULKAN_HPP_NODISCARD
15779       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
15780       getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15781     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
15782               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15783               typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type,
15784                                                    VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value,
15785                                       int>::type                     = 0>
15786     VULKAN_HPP_NODISCARD
15787       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
15788       getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
15789                                   Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15790 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15791 
15792     //=== VK_EXT_tooling_info ===
15793 
15794     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15795     VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t *                                           pToolCount,
15796                                                       VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,
15797                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15798 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15799     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
15800               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15801     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
15802       getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15803     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
15804               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15805               typename std::enable_if<
15806                 std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
15807                 int>::type = 0>
15808     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
15809       getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
15810                             Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15811 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15812 
15813     //=== VK_NV_cooperative_matrix ===
15814 
15815     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15816     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t *                                            pPropertyCount,
15817                                                                   VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
15818                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15819 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15820     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
15821               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15822     VULKAN_HPP_NODISCARD
15823       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
15824       getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15825     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
15826               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15827               typename std::enable_if<
15828                 std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value,
15829                 int>::type = 0>
15830     VULKAN_HPP_NODISCARD
15831       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
15832       getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
15833                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15834 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15835 
15836     //=== VK_NV_coverage_reduction_mode ===
15837 
15838     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15839     VULKAN_HPP_NODISCARD Result
15840       getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t *                                                   pCombinationCount,
15841                                                          VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
15842                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15843 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15844     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
15845               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15846     VULKAN_HPP_NODISCARD
15847       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
15848       getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15849     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
15850               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15851               typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type,
15852                                                    VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value,
15853                                       int>::type                     = 0>
15854     VULKAN_HPP_NODISCARD
15855       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
15856       getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
15857                                                          Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15858 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15859 
15860 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15861     //=== VK_EXT_full_screen_exclusive ===
15862 
15863     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15864     VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
15865                                                             uint32_t *                                                  pPresentModeCount,
15866                                                             VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,
15867                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15868 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15869     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15870     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
15871       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15872                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15873     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
15874               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15875               typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
15876     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
15877       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15878                                   PresentModeKHRAllocator &                                   presentModeKHRAllocator,
15879                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15880 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15881 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
15882 
15883     //=== VK_EXT_acquire_drm_display ===
15884 
15885 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15886     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15887     VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t                          drmFd,
15888                                                       VULKAN_HPP_NAMESPACE::DisplayKHR display,
15889                                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15890 #else
15891     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15892     typename ResultValueType<void>::type
15893          acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15894 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15895 
15896     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15897     VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t                            drmFd,
15898                                                   uint32_t                           connectorId,
15899                                                   VULKAN_HPP_NAMESPACE::DisplayKHR * display,
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::DisplayKHR>::type
15904       getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15905 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
15906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15907     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
15908       getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15909 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15910 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15911 
15912     //=== VK_KHR_video_encode_queue ===
15913 
15914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15915     VULKAN_HPP_NODISCARD Result
15916       getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
15917                                                VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR *               pQualityLevelProperties,
15918                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15919 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15920     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15921     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>::type
15922       getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
15923                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15924     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15925     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
15926       getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
15927                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15928 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15929 
15930 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15931     //=== VK_NV_acquire_winrt_display ===
15932 
15933 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15935     VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
15936                                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15937 #  else
15938     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15939     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15940       acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15941 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15942 
15943     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15944     VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t                           deviceRelativeId,
15945                                                    VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
15946                                                    Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15947 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15948     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15949     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
15950       getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15951 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
15952     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15953     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
15954       getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15955 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
15956 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15957 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
15958 
15959 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
15960     //=== VK_EXT_directfb_surface ===
15961 
15962     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15963     Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
15964                                               IDirectFB *        dfb,
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     VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
15969                                                                     IDirectFB &        dfb,
15970                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15971 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15972 #endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
15973 
15974 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
15975     //=== VK_QNX_screen_surface ===
15976 
15977     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15978     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
15979                                             struct _screen_window * window,
15980                                             Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15981 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15982     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15983     VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
15984                                                                   struct _screen_window & window,
15985                                                                   Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15986 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15987 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
15988 
15989     //=== VK_NV_optical_flow ===
15990 
15991     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15992     VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
15993                                                               uint32_t *                                                 pFormatCount,
15994                                                               VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties,
15995                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15996 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15997     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
15998               typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15999     VULKAN_HPP_NODISCARD
16000       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
16001       getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
16002                                     Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16003     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
16004               typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16005               typename std::enable_if<
16006                 std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value,
16007                 int>::type = 0>
16008     VULKAN_HPP_NODISCARD
16009       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
16010       getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
16011                                     OpticalFlowImageFormatPropertiesNVAllocator &              opticalFlowImageFormatPropertiesNVAllocator,
16012                                     Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16013 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16014 
16015     //=== VK_KHR_cooperative_matrix ===
16016 
16017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16018     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t *                                             pPropertyCount,
16019                                                                    VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR * pProperties,
16020                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16021 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16022     template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,
16023               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16024     VULKAN_HPP_NODISCARD
16025       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
16026       getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16027     template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,
16028               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16029               typename std::enable_if<
16030                 std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value,
16031                 int>::type = 0>
16032     VULKAN_HPP_NODISCARD
16033       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
16034       getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,
16035                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16036 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16037 
16038     //=== VK_KHR_calibrated_timestamps ===
16039 
16040     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16041     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t *                            pTimeDomainCount,
16042                                                                 VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
16043                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16044 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16045     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16046     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
16047       getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16048     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
16049               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16050               typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
16051     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
16052       getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16054 
operator VkPhysicalDevice() const16055     operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
16056     {
16057       return m_physicalDevice;
16058     }
16059 
operator bool() const16060     explicit operator bool() const VULKAN_HPP_NOEXCEPT
16061     {
16062       return m_physicalDevice != VK_NULL_HANDLE;
16063     }
16064 
operator !() const16065     bool operator!() const VULKAN_HPP_NOEXCEPT
16066     {
16067       return m_physicalDevice == VK_NULL_HANDLE;
16068     }
16069 
16070   private:
16071     VkPhysicalDevice m_physicalDevice = {};
16072   };
16073 
16074   template <>
16075   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
16076   {
16077     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
16078   };
16079 
16080   template <>
16081   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
16082   {
16083     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
16084   };
16085 
16086 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
16087   template <>
16088   struct CppType<VkPhysicalDevice, VK_NULL_HANDLE>
16089   {
16090     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
16091   };
16092 #endif
16093 
16094   template <>
16095   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
16096   {
16097     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
16098   };
16099 
16100   class Instance
16101   {
16102   public:
16103     using CType      = VkInstance;
16104     using NativeType = VkInstance;
16105 
16106     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
16107     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
16108       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
16109 
16110   public:
16111     Instance()                                   = default;
16112     Instance( Instance const & rhs )             = default;
16113     Instance & operator=( Instance const & rhs ) = default;
16114     Instance( Instance && rhs )                  = default;
16115     Instance & operator=( Instance && rhs )      = default;
16116 
Instance(std::nullptr_t)16117     VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
16118 
Instance(VkInstance instance)16119     Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
16120 
operator =(VkInstance instance)16121     Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
16122     {
16123       m_instance = instance;
16124       return *this;
16125     }
16126 
operator =(std::nullptr_t)16127     Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
16128     {
16129       m_instance = {};
16130       return *this;
16131     }
16132 
16133 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
16134     auto operator<=>( Instance const & ) const = default;
16135 #else
operator ==(Instance const & rhs) const16136     bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
16137     {
16138       return m_instance == rhs.m_instance;
16139     }
16140 
operator !=(Instance const & rhs) const16141     bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
16142     {
16143       return m_instance != rhs.m_instance;
16144     }
16145 
operator <(Instance const & rhs) const16146     bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
16147     {
16148       return m_instance < rhs.m_instance;
16149     }
16150 #endif
16151 
16152     //=== VK_VERSION_1_0 ===
16153 
16154     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16155     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16156                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16158     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16159     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16160                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16161 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16162 
16163     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16164     VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,
16165                                                           VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
16166                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16167 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16168     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16169     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type
16170       enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16171     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>,
16172               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16173               typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type = 0>
16174     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type
16175       enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16176 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16177 
16178     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16179     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16180 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16181     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16182     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16183 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16184 
16185     //=== VK_VERSION_1_1 ===
16186 
16187     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16188     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t *                                            pPhysicalDeviceGroupCount,
16189                                                                VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
16190                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16191 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16192     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
16193               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16194     VULKAN_HPP_NODISCARD
16195       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
16196       enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16197     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
16198               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16199               typename std::enable_if<
16200                 std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
16201                 int>::type = 0>
16202     VULKAN_HPP_NODISCARD
16203       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
16204       enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
16205                                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16206 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16207 
16208     //=== VK_KHR_surface ===
16209 
16210     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16211     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
16212                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16213                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16214 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16215     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16216     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface                            VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
16217                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16218                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16219 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16220 
16221     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16222     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
16223                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16224                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16225 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16227     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                                    surface,
16228                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16229                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16230 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16231 
16232     //=== VK_KHR_display ===
16233 
16234     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16235     VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
16236                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
16237                                                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
16238                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16239 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16240     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16241     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16242       createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &           createInfo,
16243                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16244                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16245 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
16246     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16247     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16248       createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &           createInfo,
16249                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16250                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16251 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
16252 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16253 
16254 #if defined( VK_USE_PLATFORM_XLIB_KHR )
16255     //=== VK_KHR_xlib_surface ===
16256 
16257     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16258     VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
16259                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
16260                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
16261                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16262 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16263     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16264     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16265       createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,
16266                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16267                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16268 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16269     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16270     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16271       createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,
16272                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16273                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16274 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16275 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16276 #endif     /*VK_USE_PLATFORM_XLIB_KHR*/
16277 
16278 #if defined( VK_USE_PLATFORM_XCB_KHR )
16279     //=== VK_KHR_xcb_surface ===
16280 
16281     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16282     VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
16283                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
16284                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
16285                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16286 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16287     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16288     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16289       createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,
16290                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16291                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16292 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16293     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16294     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16295       createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,
16296                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16297                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16298 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16299 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16300 #endif     /*VK_USE_PLATFORM_XCB_KHR*/
16301 
16302 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
16303     //=== VK_KHR_wayland_surface ===
16304 
16305     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16306     VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
16307                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
16308                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
16309                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16310 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16311     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16312     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16313       createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,
16314                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16315                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16316 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16317     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16318     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16319       createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,
16320                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16321                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16322 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16323 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16324 #endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/
16325 
16326 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
16327     //=== VK_KHR_android_surface ===
16328 
16329     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16330     VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
16331                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
16332                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
16333                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16334 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16335     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16336     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16337       createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,
16338                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16339                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16340 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16341     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16342     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16343       createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,
16344                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16345                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16346 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16347 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16348 #endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
16349 
16350 #if defined( VK_USE_PLATFORM_WIN32_KHR )
16351     //=== VK_KHR_win32_surface ===
16352 
16353     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16354     VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
16355                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
16356                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
16357                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16358 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16359     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16360     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16361       createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,
16362                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16363                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16364 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16365     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16366     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16367       createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,
16368                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16369                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16370 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16371 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16372 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
16373 
16374     //=== VK_EXT_debug_report ===
16375 
16376     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16377     VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
16378                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
16379                                                               VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
16380                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16381 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16382     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16383     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type
16384       createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,
16385                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16386                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16387 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
16388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16389     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
16390       createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,
16391                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16392                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16393 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
16394 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16395 
16396     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16397     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
16398                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16399                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16400 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16401     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16402     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
16403                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16404                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16405 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16406 
16407     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16408     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
16409                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16410                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16411 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16412     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16413     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT                        callback,
16414                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16415                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16416 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16417 
16418     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16419     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
16420                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
16421                                 uint64_t                                       object,
16422                                 size_t                                         location,
16423                                 int32_t                                        messageCode,
16424                                 const char *                                   pLayerPrefix,
16425                                 const char *                                   pMessage,
16426                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16427 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16428     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16429     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
16430                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
16431                                 uint64_t                                       object,
16432                                 size_t                                         location,
16433                                 int32_t                                        messageCode,
16434                                 const std::string &                            layerPrefix,
16435                                 const std::string &                            message,
16436                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16437 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16438 
16439 #if defined( VK_USE_PLATFORM_GGP )
16440     //=== VK_GGP_stream_descriptor_surface ===
16441 
16442     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16443     VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
16444                                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
16445                                                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
16446                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16447 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16448     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16449     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16450       createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,
16451                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16452                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16453 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16454     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16455     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createStreamDescriptorSurfaceGGPUnique(
16456       const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,
16457       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16458       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16459 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16460 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16461 #endif     /*VK_USE_PLATFORM_GGP*/
16462 
16463 #if defined( VK_USE_PLATFORM_VI_NN )
16464     //=== VK_NN_vi_surface ===
16465 
16466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16467     VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
16468                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
16469                                                    VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
16470                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16471 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16472     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16473     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16474       createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,
16475                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16476                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16477 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16479     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16480       createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,
16481                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16482                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16483 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16484 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16485 #endif     /*VK_USE_PLATFORM_VI_NN*/
16486 
16487     //=== VK_KHR_device_group_creation ===
16488 
16489     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16490     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t *                                            pPhysicalDeviceGroupCount,
16491                                                                   VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
16492                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16494     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
16495               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16496     VULKAN_HPP_NODISCARD
16497       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
16498       enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16499     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
16500               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16501               typename std::enable_if<
16502                 std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
16503                 int>::type = 0>
16504     VULKAN_HPP_NODISCARD
16505       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
16506       enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
16507                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16508 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16509 
16510 #if defined( VK_USE_PLATFORM_IOS_MVK )
16511     //=== VK_MVK_ios_surface ===
16512 
16513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16514     VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
16515                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
16516                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
16517                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16518 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16519     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16520     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16521       createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,
16522                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16523                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16524 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16526     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16527       createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,
16528                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16529                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16530 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16531 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16532 #endif     /*VK_USE_PLATFORM_IOS_MVK*/
16533 
16534 #if defined( VK_USE_PLATFORM_MACOS_MVK )
16535     //=== VK_MVK_macos_surface ===
16536 
16537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16538     VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
16539                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
16540                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
16541                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16542 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16543     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16544     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16545       createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,
16546                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16547                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16548 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16550     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16551       createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,
16552                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16553                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16554 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16555 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16556 #endif     /*VK_USE_PLATFORM_MACOS_MVK*/
16557 
16558     //=== VK_EXT_debug_utils ===
16559 
16560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16561     VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
16562                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
16563                                                               VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
16564                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16565 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16566     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16567     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type
16568       createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &      createInfo,
16569                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16570                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16571 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
16572     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16573     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
16574       createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &      createInfo,
16575                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16576                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16577 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
16578 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16579 
16580     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16581     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
16582                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16583                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16584 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16585     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16586     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
16587                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16588                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16589 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16590 
16591     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16592     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
16593                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16594                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16595 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16596     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16597     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT                        messenger,
16598                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16599                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16600 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16601 
16602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16603     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
16604                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
16605                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
16606                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16607 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16608     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16609     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
16610                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
16611                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData,
16612                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16613 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16614 
16615 #if defined( VK_USE_PLATFORM_FUCHSIA )
16616     //=== VK_FUCHSIA_imagepipe_surface ===
16617 
16618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16619     VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
16620                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
16621                                                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
16622                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16623 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16624     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16625     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16626       createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,
16627                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16628                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16629 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16630     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16631     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16632       createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,
16633                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16634                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16635 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16636 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16637 #endif     /*VK_USE_PLATFORM_FUCHSIA*/
16638 
16639 #if defined( VK_USE_PLATFORM_METAL_EXT )
16640     //=== VK_EXT_metal_surface ===
16641 
16642     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16643     VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
16644                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
16645                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
16646                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16647 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16648     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16649     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16650       createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,
16651                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16652                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16653 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16654     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16655     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16656       createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,
16657                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16658                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16659 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16660 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16661 #endif     /*VK_USE_PLATFORM_METAL_EXT*/
16662 
16663     //=== VK_EXT_headless_surface ===
16664 
16665     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16666     VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
16667                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
16668                                                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
16669                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16670 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16671     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16672     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16673       createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &          createInfo,
16674                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16675                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16676 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
16677     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16678     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16679       createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &          createInfo,
16680                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16681                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16682 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
16683 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16684 
16685 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
16686     //=== VK_EXT_directfb_surface ===
16687 
16688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16689     VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
16690                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
16691                                                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
16692                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16693 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16694     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16695     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16696       createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,
16697                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16698                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16699 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16700     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16701     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16702       createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,
16703                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16704                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16705 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16706 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16707 #endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
16708 
16709 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
16710     //=== VK_QNX_screen_surface ===
16711 
16712     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16713     VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
16714                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
16715                                                         VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,
16716                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16717 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16718     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16719     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
16720       createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,
16721                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16722                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16723 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16725     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
16726       createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,
16727                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16728                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16729 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16730 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16731 #endif     /*VK_USE_PLATFORM_SCREEN_QNX*/
16732 
operator VkInstance() const16733     operator VkInstance() const VULKAN_HPP_NOEXCEPT
16734     {
16735       return m_instance;
16736     }
16737 
operator bool() const16738     explicit operator bool() const VULKAN_HPP_NOEXCEPT
16739     {
16740       return m_instance != VK_NULL_HANDLE;
16741     }
16742 
operator !() const16743     bool operator!() const VULKAN_HPP_NOEXCEPT
16744     {
16745       return m_instance == VK_NULL_HANDLE;
16746     }
16747 
16748   private:
16749     VkInstance m_instance = {};
16750   };
16751 
16752   template <>
16753   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
16754   {
16755     using Type = VULKAN_HPP_NAMESPACE::Instance;
16756   };
16757 
16758   template <>
16759   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
16760   {
16761     using Type = VULKAN_HPP_NAMESPACE::Instance;
16762   };
16763 
16764 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
16765   template <>
16766   struct CppType<VkInstance, VK_NULL_HANDLE>
16767   {
16768     using Type = VULKAN_HPP_NAMESPACE::Instance;
16769   };
16770 #endif
16771 
16772   template <>
16773   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
16774   {
16775     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
16776   };
16777 
16778   //=== VK_VERSION_1_0 ===
16779 
16780   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16781   VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *  pCreateInfo,
16782                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16783                                               VULKAN_HPP_NAMESPACE::Instance *                  pInstance,
16784                                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
16785 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16786   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16787   VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type
16788     createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,
16789                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16790                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16791 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
16792   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16793   VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type
16794     createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,
16795                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16796                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16797 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
16798 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16799 
16800   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16801   VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char *                                pLayerName,
16802                                                                     uint32_t *                                  pPropertyCount,
16803                                                                     VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
16804                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
16805 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16806   template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
16807             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16808   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
16809     enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16810                                           Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16811   template <
16812     typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
16813     typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16814     typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
16815   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
16816     enumerateInstanceExtensionProperties( Optional<const std::string>    layerName,
16817                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
16818                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16819 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16820 
16821   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16822   VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t *                              pPropertyCount,
16823                                                                 VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
16824                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
16825 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16826   template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16827   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
16828     enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16829   template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
16830             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16831             typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
16832   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
16833     enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16834 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16835 
16836   //=== VK_VERSION_1_1 ===
16837 
16838   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16839   VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t *         pApiVersion,
16840                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
16841 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16842   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16843   VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16844 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16845 
16846 }  // namespace VULKAN_HPP_NAMESPACE
16847 
16848 // operators to compare vk::-handles with nullptr
16849 template <typename T>
operator ==(const T & v,std::nullptr_t)16850 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( const T & v, std::nullptr_t )
16851 {
16852   return !v;
16853 }
16854 
16855 template <typename T>
operator ==(std::nullptr_t,const T & v)16856 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( std::nullptr_t, const T & v )
16857 {
16858   return !v;
16859 }
16860 
16861 template <typename T>
operator !=(const T & v,std::nullptr_t)16862 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( const T & v, std::nullptr_t )
16863 {
16864   return v;
16865 }
16866 
16867 template <typename T>
operator !=(std::nullptr_t,const T & v)16868 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( std::nullptr_t, const T & v )
16869 {
16870   return v;
16871 }
16872 #endif
16873